Release v2.3.65

- Check for @pytest.mark.integration marker
- Check if test file is in integration/ directory
- This prevents conftest from overriding real API keys with 'test-key'

README.md

@@ -191,8 +191,14 @@ npm install praisonai
 | 📚 Add Custom Knowledge | [Example](examples/python/concepts/knowledge-agents.py) | [📖](https://docs.praison.ai/features/knowledge) |
 | 🧠 Memory (Short & Long Term) | [Example](examples/python/general/memory_example.py) | [📖](https://docs.praison.ai/concepts/memory) |
 | 📄 Chat with PDF Agents | [Example](examples/python/concepts/chat-with-pdf.py) | [📖](https://docs.praison.ai/features/chat-with-pdf) |
-| 💻 Code Interpreter Agents | [Example](examples/python/agents/code-agent.py) | [📖](https://docs.praison.ai/features/codeagent) |
-| ✏️ AI Code Editing Tools | [Example](#ai-code-editing) | [📖](https://docs.praison.ai/features/code) |
+| **💻 Code** | | |
+| ↳ Code Interpreter Agents | [Example](examples/python/agents/code-agent.py) | [📖](https://docs.praison.ai/features/codeagent) |
+| ↳ AI Code Editing Tools | [Example](examples/python/code/code_editing_example.py) | [📖](https://docs.praison.ai/code/editing) |
+| ↳ External Agents (All) | [Example](examples/python/code/external_agents_example.py) | [📖](https://docs.praison.ai/code/external-agents) |
+| ↳ Claude Code CLI | [Example](examples/python/code/claude_code_example.py) | [📖](https://docs.praison.ai/code/claude-code) |
+| ↳ Gemini CLI | [Example](examples/python/code/gemini_cli_example.py) | [📖](https://docs.praison.ai/code/gemini-cli) |
+| ↳ Codex CLI | [Example](examples/python/code/codex_cli_example.py) | [📖](https://docs.praison.ai/code/codex-cli) |
+| ↳ Cursor CLI | [Example](examples/python/code/cursor_cli_example.py) | [📖](https://docs.praison.ai/code/cursor-cli) |
 | 📚 RAG Agents | [Example](examples/python/concepts/rag-agents.py) | [📖](https://docs.praison.ai/features/rag) |
 | 🤔 Async & Parallel Processing | [Example](examples/python/general/async_example.py) | [📖](https://docs.praison.ai/features/async) |
 | 🔢 Math Agents | [Example](examples/python/agents/math-agent.py) | [📖](https://docs.praison.ai/features/mathagent) |
@@ -230,7 +236,7 @@ npm install praisonai
 | 💻 Programming Agent | [Example](examples/python/agents/programming-agent.py) | [📖](https://docs.praison.ai/agents/programming) |
 | 📝 Markdown Agent | [Example](examples/python/agents/markdown-agent.py) | [📖](https://docs.praison.ai/agents/markdown) |
 | 📝 Prompt Expander Agent | [Example](#prompt-expansion) | [📖](https://docs.praison.ai/agents/prompt-expander) |
-| 🔀 Router Agent | [Example](examples/python/agents/router-agent-cost-optimization.py) | [📖](https://docs.praison.ai/features/routing) |
+| 🔀 Model Router | [Example](examples/python/agents/router-agent-cost-optimization.py) | [📖](https://docs.praison.ai/features/model-router) |
 | ⛓️ Prompt Chaining | [Example](examples/python/general/prompt_chaining.py) | [📖](https://docs.praison.ai/features/promptchaining) |
 | 🔍 Evaluator Optimiser | [Example](examples/python/general/evaluator-optimiser.py) | [📖](https://docs.praison.ai/features/evaluator-optimiser) |
 | 👷 Orchestrator Workers | [Example](examples/python/general/orchestrator-workers.py) | [📖](https://docs.praison.ai/features/orchestrator-worker) |
@@ -246,12 +252,22 @@ npm install praisonai
 | 🪝 Hooks | [Example](#9-hooks) | [📖](https://docs.praison.ai/features/hooks) |
 | 📈 Telemetry | [Example](examples/python/telemetry/production-telemetry-example.py) | [📖](https://docs.praison.ai/features/telemetry) |
 | 📹 Camera Integration | [Example](examples/python/camera/) | [📖](https://docs.praison.ai/features/camera-integration) |
-| 📄 Project Docs (.praison/docs/) | [Example](#docs-cli) | [📖](https://docs.praison.ai/cli/docs) |
-| 🔌 MCP Config Management | [Example](#mcp-config-cli) | [📖](https://docs.praison.ai/cli/mcp) |
-| 💬 AI Commit Messages | [Example](#ai-commit-cli) | [📖](https://docs.praison.ai/cli/commit) |
-| @ @Mentions in Prompts | [Example](#mentions-in-prompts) | [📖](https://docs.praison.ai/cli/mentions) |
-| 💾 Auto-Save Sessions | [Example](#session-management-python) | [📖](https://docs.praison.ai/cli/session) |
-| 📜 History in Context | [Example](#session-management-python) | [📖](https://docs.praison.ai/cli/session) |
+| 📄 Project Docs (.praison/docs/) | [Example](#docs-cli) | [📖](https://docs.praison.ai/docs/cli/docs) |
+| 🔌 MCP Config Management | [Example](#mcp-config-cli) | [📖](https://docs.praison.ai/docs/cli/mcp) |
+| 💬 AI Commit Messages | [Example](#ai-commit-cli) | [📖](https://docs.praison.ai/docs/cli/commit) |
+| @ @Mentions in Prompts | [Example](#mentions-in-prompts) | [📖](https://docs.praison.ai/docs/cli/mentions) |
+| 💾 Auto-Save Sessions | [Example](#session-management-python) | [📖](https://docs.praison.ai/docs/cli/session) |
+| 📜 History in Context | [Example](#session-management-python) | [📖](https://docs.praison.ai/docs/cli/session) |
+| **🖥️ CLI Features** | | |
+| ↳ Slash Commands | [Example](examples/python/cli/slash_commands_example.py) | [📖](https://docs.praison.ai/docs/cli/slash-commands) |
+| ↳ Autonomy Modes | [Example](examples/python/cli/autonomy_modes_example.py) | [📖](https://docs.praison.ai/docs/cli/autonomy-modes) |
+| ↳ Cost Tracking | [Example](examples/python/cli/cost_tracking_example.py) | [📖](https://docs.praison.ai/docs/cli/cost-tracking) |
+| ↳ Repository Map | [Example](examples/python/cli/repo_map_example.py) | [📖](https://docs.praison.ai/docs/cli/repo-map) |
+| ↳ Interactive TUI | [Example](examples/python/cli/interactive_tui_example.py) | [📖](https://docs.praison.ai/docs/cli/interactive-tui) |
+| ↳ Git Integration | [Example](examples/python/cli/git_integration_example.py) | [📖](https://docs.praison.ai/docs/cli/git-integration) |
+| ↳ Sandbox Execution | [Example](examples/python/cli/sandbox_execution_example.py) | [📖](https://docs.praison.ai/docs/cli/sandbox-execution) |
+| **⏰ 24/7 Scheduling** | | |
+| ↳ Agent Scheduler | [Example](examples/python/scheduled_agents/news_checker_live.py) | [📖](https://docs.praison.ai/docs/cli/scheduler) |
 
 ---
 
@@ -958,6 +974,32 @@ export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
 praisonai --auto create a movie script about Robots in Mars
 ```
 
+### Interactive Mode CLI:
+```bash
+# Start interactive terminal mode (inspired by Gemini CLI, Codex CLI, Claude Code)
+praisonai --interactive
+praisonai -i
+
+# Features:
+# - Streaming responses (no boxes)
+# - Built-in tools: read_file, write_file, list_files, execute_command, internet_search
+# - Slash commands: /help, /exit, /tools, /clear
+
+# Chat mode - single prompt with interactive style (for testing/scripting)
+# Use --chat (or --chat-mode for backward compatibility)
+praisonai "list files in current folder" --chat
+praisonai "search the web for AI news" --chat
+praisonai "read README.md" --chat
+```
+
+### Chat UI (Web Interface):
+```bash
+# Start web-based Chainlit chat interface (requires praisonai[chat])
+pip install "praisonai[chat]"
+praisonai chat
+# Opens browser at http://localhost:8084
+```
+
 ### Query Rewriting (works with any command):
 ```bash
 # Rewrite query for better results (uses QueryRewriterAgent)
@@ -1018,6 +1060,20 @@ praisonai "Complex analysis task" --planning --planning-reasoning
 praisonai "Task" --planning --auto-approve-plan
 ```
 
+### Tool Approval CLI:
+```bash
+# Auto-approve ALL tool executions (use with caution!)
+praisonai "run ls command" --trust
+
+# Auto-approve tools up to a risk level (prompt for higher)
+# Levels: low, medium, high, critical
+praisonai "write to file" --approve-level high  # Prompts for critical tools only
+praisonai "task" --approve-level medium         # Prompts for high and critical
+
+# Default behavior (no flags): prompts for all dangerous tools
+praisonai "run shell command"  # Will prompt for approval
+```
+
 ### Memory CLI:
 ```bash
 # Enable memory for agent (persists across sessions)
@@ -1188,6 +1244,36 @@ praisonai "Analyze this data" --metrics
 praisonai "Complex task" --metrics --planning
 ```
 
+### Scheduler CLI:
+```bash
+# Schedule an agent using agents.yaml
+praisonai schedule agents.yaml
+
+# Override interval from CLI
+praisonai schedule agents.yaml --interval "*/30m"
+
+# With verbose logging
+praisonai schedule agents.yaml --verbose
+```
+
+**agents.yaml with schedule:**
+```yaml
+framework: praisonai
+
+agents:
+  - name: "AI News Monitor"
+    instructions: "Search and summarize AI news"
+    tools:
+      - search_tool
+
+task: "Search for latest AI news"
+
+schedule:
+  interval: "hourly"  # hourly, daily, */30m, */6h
+  max_retries: 3
+  run_immediately: true
+```
+
 ### Image Processing CLI:
 ```bash
 # Process images with vision-based tasks
@@ -1374,8 +1460,13 @@ praisonai "Complex analysis" --router --router-provider anthropic
 # Router automatically selects:
 # - Simple tasks → gpt-4o-mini, claude-3-haiku
 # - Complex tasks → gpt-4-turbo, claude-3-opus
+
+# Create workflow with model routing template
+praisonai workflow create --template model-routing --output my_workflow.yaml
 ```
 
+Custom models can be configured in `agents.yaml`. See [Model Router Docs](https://docs.praison.ai/features/model-router) for details.
+
 ### Flow Display CLI:
 ```bash
 # Enable visual workflow tracking
@@ -1427,13 +1518,31 @@ praisonai mcp help
 
 ### AI Commit CLI:
 ```bash
-# Generate AI commit message for staged changes
+# Full auto mode: stage all, security check, commit, and push
+praisonai commit -a
+
+# Interactive mode (requires git add first)
 praisonai commit
 
-# Generate, commit, and push
+# Interactive with auto-push
 praisonai commit --push
+
+# Skip security check (not recommended)
+praisonai commit -a --no-verify
 ```
 
+**Features:**
+- 🤖 AI-generated conventional commit messages
+- 🔒 Built-in security scanning (API keys, passwords, secrets, sensitive files)
+- 📦 Auto-staging with `-a` flag
+- 🚀 Auto-push in full auto mode
+- ✏️ Edit message before commit in interactive mode
+
+**Security Detection:**
+- API keys, secrets, tokens (AWS, GitHub, GitLab, Slack)
+- Passwords and private keys
+- Sensitive files (`.env`, `id_rsa`, `.pem`, `.key`, etc.)
+
 ### Serve CLI (API Server):
 ```bash
 # Start API server for agents defined in YAML
@@ -1464,6 +1573,55 @@ export N8N_API_KEY="your-api-key"
 praisonai agents.yaml --n8n
 ```
 
+### External Agents CLI:
+
+Use external AI coding CLI tools (Claude Code, Gemini CLI, Codex CLI, Cursor CLI) as agent tools:
+
+```bash
+# Use Claude Code for coding tasks
+praisonai "Refactor the auth module" --external-agent claude
+
+# Use Gemini CLI for code analysis
+praisonai "Analyze codebase architecture" --external-agent gemini
+
+# Use OpenAI Codex CLI
+praisonai "Fix all bugs in src/" --external-agent codex
+
+# Use Cursor CLI
+praisonai "Add comprehensive tests" --external-agent cursor
+```
+
+**Python API:**
+```python
+from praisonai.integrations import (
+    ClaudeCodeIntegration,
+    GeminiCLIIntegration,
+    CodexCLIIntegration,
+    CursorCLIIntegration
+)
+
+# Create integration
+claude = ClaudeCodeIntegration(workspace="/project")
+
+# Execute a coding task
+result = await claude.execute("Refactor the auth module")
+
+# Use as agent tool
+from praisonai import Agent
+tool = claude.as_tool()
+agent = Agent(tools=[tool])
+```
+
+**Environment Variables:**
+```bash
+export ANTHROPIC_API_KEY=your-key  # Claude Code
+export GEMINI_API_KEY=your-key     # Gemini CLI
+export OPENAI_API_KEY=your-key     # Codex CLI
+export CURSOR_API_KEY=your-key     # Cursor CLI
+```
+
+See [External Agents Documentation](https://docs.praison.ai/code/external-agents) for more details.
+
 ### @Mentions in Prompts:
 ```bash
 # Include file content in prompt
@@ -1689,32 +1847,32 @@ app.include_router(a2a.get_router())
 
 | Feature | Docs |
 |---------|:----:|
-| 🔄 Query Rewrite - RAG optimization | [📖](https://docs.praison.ai/cli/query-rewrite) |
-| 🔬 Deep Research - Automated research | [📖](https://docs.praison.ai/cli/deep-research) |
-| 📋 Planning - Step-by-step execution | [📖](https://docs.praison.ai/cli/planning) |
-| 💾 Memory - Persistent agent memory | [📖](https://docs.praison.ai/cli/memory) |
-| 📜 Rules - Auto-discovered instructions | [📖](https://docs.praison.ai/cli/rules) |
-| 🔄 Workflow - Multi-step workflows | [📖](https://docs.praison.ai/cli/workflow) |
-| 🪝 Hooks - Event-driven actions | [📖](https://docs.praison.ai/cli/hooks) |
-| 🧠 Claude Memory - Anthropic memory tool | [📖](https://docs.praison.ai/cli/claude-memory) |
-| 🛡️ Guardrail - Output validation | [📖](https://docs.praison.ai/cli/guardrail) |
-| 📊 Metrics - Token usage tracking | [📖](https://docs.praison.ai/cli/metrics) |
-| 🖼️ Image - Vision processing | [📖](https://docs.praison.ai/cli/image) |
-| 📡 Telemetry - Usage monitoring | [📖](https://docs.praison.ai/cli/telemetry) |
-| 🔌 MCP - Model Context Protocol | [📖](https://docs.praison.ai/cli/mcp) |
-| ⚡ Fast Context - Codebase search | [📖](https://docs.praison.ai/cli/fast-context) |
-| 📚 Knowledge - RAG management | [📖](https://docs.praison.ai/cli/knowledge) |
-| 💬 Session - Conversation management | [📖](https://docs.praison.ai/cli/session) |
-| 🔧 Tools - Tool discovery | [📖](https://docs.praison.ai/cli/tools) |
-| 🤝 Handoff - Agent delegation | [📖](https://docs.praison.ai/cli/handoff) |
-| 🧠 Auto Memory - Memory extraction | [📖](https://docs.praison.ai/cli/auto-memory) |
-| 📋 Todo - Task management | [📖](https://docs.praison.ai/cli/todo) |
-| 🎯 Router - Smart model selection | [📖](https://docs.praison.ai/cli/router) |
-| 📈 Flow Display - Visual workflow | [📖](https://docs.praison.ai/cli/flow-display) |
-| ✨ Prompt Expansion - Detailed prompts | [📖](https://docs.praison.ai/cli/prompt-expansion) |
-| 🌐 Web Search - Real-time search | [📖](https://docs.praison.ai/cli/web-search) |
-| 📥 Web Fetch - URL content retrieval | [📖](https://docs.praison.ai/cli/web-fetch) |
-| 💾 Prompt Caching - Cost reduction | [📖](https://docs.praison.ai/cli/prompt-caching) |
+| 🔄 Query Rewrite - RAG optimization | [📖](https://docs.praison.ai/docs/cli/query-rewrite) |
+| 🔬 Deep Research - Automated research | [📖](https://docs.praison.ai/docs/cli/deep-research) |
+| 📋 Planning - Step-by-step execution | [📖](https://docs.praison.ai/docs/cli/planning) |
+| 💾 Memory - Persistent agent memory | [📖](https://docs.praison.ai/docs/cli/memory) |
+| 📜 Rules - Auto-discovered instructions | [📖](https://docs.praison.ai/docs/cli/rules) |
+| 🔄 Workflow - Multi-step workflows | [📖](https://docs.praison.ai/docs/cli/workflow) |
+| 🪝 Hooks - Event-driven actions | [📖](https://docs.praison.ai/docs/cli/hooks) |
+| 🧠 Claude Memory - Anthropic memory tool | [📖](https://docs.praison.ai/docs/cli/claude-memory) |
+| 🛡️ Guardrail - Output validation | [📖](https://docs.praison.ai/docs/cli/guardrail) |
+| 📊 Metrics - Token usage tracking | [📖](https://docs.praison.ai/docs/cli/metrics) |
+| 🖼️ Image - Vision processing | [📖](https://docs.praison.ai/docs/cli/image) |
+| 📡 Telemetry - Usage monitoring | [📖](https://docs.praison.ai/docs/cli/telemetry) |
+| 🔌 MCP - Model Context Protocol | [📖](https://docs.praison.ai/docs/cli/mcp) |
+| ⚡ Fast Context - Codebase search | [📖](https://docs.praison.ai/docs/cli/fast-context) |
+| 📚 Knowledge - RAG management | [📖](https://docs.praison.ai/docs/cli/knowledge) |
+| 💬 Session - Conversation management | [📖](https://docs.praison.ai/docs/cli/session) |
+| 🔧 Tools - Tool discovery | [📖](https://docs.praison.ai/docs/cli/tools) |
+| 🤝 Handoff - Agent delegation | [📖](https://docs.praison.ai/docs/cli/handoff) |
+| 🧠 Auto Memory - Memory extraction | [📖](https://docs.praison.ai/docs/cli/auto-memory) |
+| 📋 Todo - Task management | [📖](https://docs.praison.ai/docs/cli/todo) |
+| 🎯 Router - Smart model selection | [📖](https://docs.praison.ai/docs/cli/router) |
+| 📈 Flow Display - Visual workflow | [📖](https://docs.praison.ai/docs/cli/flow-display) |
+| ✨ Prompt Expansion - Detailed prompts | [📖](https://docs.praison.ai/docs/cli/prompt-expansion) |
+| 🌐 Web Search - Real-time search | [📖](https://docs.praison.ai/docs/cli/web-search) |
+| 📥 Web Fetch - URL content retrieval | [📖](https://docs.praison.ai/docs/cli/web-fetch) |
+| 💾 Prompt Caching - Cost reduction | [📖](https://docs.praison.ai/docs/cli/prompt-caching) |
 
 ---
 
@@ -2266,7 +2424,7 @@ PraisonAI provides zero-dependency persistent memory for agents. For detailed ex
 - 📖 **Wikipedia Agent** - Search and extract Wikipedia information
 - 💻 **Programming Agent** - Code development and analysis
 - 📝 **Markdown Agent** - Generate and format Markdown content
-- 🔀 **Router Agent** - Dynamic task routing with cost optimisation
+- 🔀 **Model Router** - Smart model selection based on task complexity
 
 ### MCP Protocol
 
@@ -2287,6 +2445,7 @@ PraisonAI provides zero-dependency persistent memory for agents. For detailed ex
 - 🤝 **Agent Handoffs** - Transfer context between specialised agents
 - 🛡️ **Guardrails** - Input/output validation and safety checks
 - ✅ **Human Approval** - Require human confirmation for critical actions
+- 🔐 **Tool Approval CLI** - `--trust` (auto-approve all) and `--approve-level` (risk-based approval)
 - 💬 **Sessions Management** - Isolated conversation contexts
 - 🔄 **Stateful Agents** - Maintain state across interactions
 

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.3.44" \
+    "praisonai>=2.3.65" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.3.44" \
+    "praisonai>=2.3.65" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.3.44" \
+    "praisonai>=2.3.65" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

examples/README.md

@@ -0,0 +1,49 @@
+# PraisonAI Examples
+
+This folder contains examples for PraisonAI. For detailed documentation, visit [docs.praison.ai](https://docs.praison.ai).
+
+## Structure
+
+```
+examples/
+├── python/           # Python examples
+│   ├── agents/       # Agent examples (single, multi, router, etc.)
+│   ├── workflows/    # Workflow patterns (routing, parallel, loop)
+│   ├── tools/        # Custom tools examples
+│   ├── mcp/          # MCP protocol examples
+│   ├── memory/       # Memory and sessions
+│   ├── code/         # Code editing and external CLI tools
+│   └── ...
+├── yaml/             # YAML workflow examples
+└── cookbooks/        # Complete use-case examples
+```
+
+## Quick Links
+
+| Category | Examples | Docs |
+|----------|----------|------|
+| **Agents** | [python/agents/](python/agents/) | [📖](https://docs.praison.ai/concepts/agents) |
+| **Workflows** | [python/workflows/](python/workflows/) | [📖](https://docs.praison.ai/features/workflows) |
+| **Model Router** | [python/agents/router-agent-cost-optimization.py](python/agents/router-agent-cost-optimization.py) | [📖](https://docs.praison.ai/features/model-router) |
+| **MCP** | [python/mcp/](python/mcp/) | [📖](https://docs.praison.ai/mcp) |
+| **Memory** | [python/memory/](python/memory/) | [📖](https://docs.praison.ai/concepts/memory) |
+| **Tools** | [python/tools/](python/tools/) | [📖](https://docs.praison.ai/tools) |
+| **Code** | [python/code/](python/code/) | [📖](https://docs.praison.ai/code) |
+| **YAML** | [yaml/](yaml/) | [📖](https://docs.praison.ai/features/yaml-workflows) |
+
+## Running Examples
+
+```bash
+# Install PraisonAI
+pip install praisonai
+
+# Set API key
+export OPENAI_API_KEY=your_key_here
+
+# Run an example
+python examples/python/agents/single-agent.py
+```
+
+## CLI Commands
+
+See the main [README.md](../README.md#-cli--no-code-interface) for all CLI commands.

examples/cookbooks/yaml/data_collector_scheduled.yaml

@@ -0,0 +1,23 @@
+# Example: Data Collection Agent with 30-minute Schedule
+# Collects and analyzes data every 30 minutes
+
+framework: praisonai
+
+agents:
+  - name: "Data Collector"
+    role: "Data Analysis Specialist"
+    goal: "Collect and analyze market data at regular intervals"
+    instructions: |
+      You are a data analysis specialist focused on collecting and analyzing
+      market trends and metrics. Provide actionable insights from the data.
+    tools:
+      - search_tool
+    verbose: false
+
+task: "Collect latest market data and identify key trends"
+
+# Schedule: Every 30 minutes with immediate execution
+schedule:
+  interval: "*/30m"
+  max_retries: 5
+  run_immediately: true

examples/cookbooks/yaml/news_monitor_scheduled.yaml

@@ -0,0 +1,53 @@
+# Example: 24/7 AI News Monitor with Scheduler
+# This agent runs continuously at regular intervals to monitor AI news
+
+framework: praisonai
+
+agents:
+  - name: "AI News Monitor"
+    role: "Technology News Analyst"
+    goal: "Monitor and summarize the latest AI developments"
+    instructions: |
+      You are an expert technology news analyst specializing in AI and machine learning.
+      Your job is to search for the latest AI news, identify the most important developments,
+      and provide clear, concise summaries with sources.
+      
+      Focus on:
+      - Major AI product launches
+      - Research breakthroughs
+      - Industry trends
+      - Policy and regulation updates
+    tools:
+      - search_tool
+    verbose: true
+
+# Task to execute on each scheduled run
+task: |
+  Search for the latest AI news from the past 24 hours.
+  Provide the top 3 most important stories with:
+  1. Headline
+  2. Brief summary (2-3 sentences)
+  3. Source URL
+  4. Why it's significant
+
+# Schedule configuration
+schedule:
+  # Interval options:
+  # - "hourly" - Every hour
+  # - "daily" - Every 24 hours
+  # - "*/30m" - Every 30 minutes
+  # - "*/6h" - Every 6 hours
+  # - "3600" - Custom seconds
+  interval: "hourly"
+  
+  # Maximum retry attempts if execution fails
+  max_retries: 3
+  
+  # Run immediately when scheduler starts (before first scheduled interval)
+  run_immediately: true
+
+# Optional: Variables for customization
+variables:
+  news_category: "AI and Machine Learning"
+  region: "Global"
+  time_range: "24 hours"

examples/python/cli/autonomy_modes_example.py

@@ -0,0 +1,38 @@
+"""
+Autonomy Modes Example for PraisonAI CLI.
+
+Control AI autonomy: suggest, auto_edit, full_auto.
+Docs: https://docs.praison.ai/cli/autonomy-modes
+"""
+
+from praisonai.cli.features import AutonomyModeHandler
+from praisonai.cli.features.autonomy_mode import ActionRequest, ActionType
+
+# Initialize with suggest mode (safest)
+handler = AutonomyModeHandler()
+manager = handler.initialize(mode="suggest")
+
+print(f"Current mode: {handler.get_mode()}")
+print("Available modes: suggest, auto_edit, full_auto")
+
+# Create an action request
+action = ActionRequest(
+    action_type=ActionType.FILE_WRITE,
+    description="Edit src/main.py to add logging",
+    details={"file": "src/main.py"}
+)
+
+# In suggest mode, this would require approval
+# For demo, we'll just show the action
+print(f"\nAction: {action.description}")
+print(f"Type: {action.action_type.value}")
+print("Would require approval in 'suggest' mode")
+
+# Change to auto_edit mode
+handler.set_mode("auto_edit")
+print(f"\nChanged to: {handler.get_mode()}")
+print("File edits now auto-approved, shell commands still require approval")
+
+# Get statistics
+stats = handler.get_stats()
+print(f"\nStats: {stats}")

examples/python/cli/cost_tracking_example.py

@@ -0,0 +1,34 @@
+"""
+Cost Tracking Example for PraisonAI CLI.
+
+Real-time token usage and cost monitoring.
+Docs: https://docs.praison.ai/cli/cost-tracking
+"""
+
+from praisonai.cli.features import CostTrackerHandler
+
+# Initialize tracker
+handler = CostTrackerHandler()
+tracker = handler.initialize(session_id="demo-session")
+
+# Track some requests
+handler.track_request("gpt-4o", input_tokens=1000, output_tokens=500)
+handler.track_request("gpt-4o-mini", input_tokens=2000, output_tokens=800)
+handler.track_request("claude-3-5-sonnet", input_tokens=1500, output_tokens=600)
+
+# Get totals
+print(f"Total tokens: {handler.get_tokens():,}")
+print(f"Total cost: ${handler.get_cost():.4f}")
+
+# Get detailed summary
+summary = handler.get_summary()
+print("\n=== Session Summary ===")
+print(f"Session ID: {summary['session_id']}")
+print(f"Total requests: {summary['total_requests']}")
+print(f"Input tokens: {summary['total_input_tokens']:,}")
+print(f"Output tokens: {summary['total_output_tokens']:,}")
+print(f"Total cost: ${summary['total_cost']:.4f}")
+print(f"Avg cost/request: ${summary['avg_cost_per_request']:.4f}")
+
+# Display formatted (uses Rich if available)
+handler.display_summary()

examples/python/cli/git_integration_example.py

@@ -0,0 +1,45 @@
+"""
+Git Integration Example for PraisonAI CLI.
+
+Auto-commit with AI messages, diff viewing, undo.
+Docs: https://docs.praison.ai/cli/git-integration
+"""
+
+from praisonai.cli.features import GitIntegrationHandler
+
+# Initialize
+handler = GitIntegrationHandler(verbose=True)
+git = handler.initialize(repo_path=".")
+
+# Check if it's a git repo
+if not git.is_repo:
+    print("Not a git repository!")
+    exit(1)
+
+# Show status
+print("=== Git Status ===")
+status = handler.show_status()
+print(f"Branch: {status.branch}")
+print(f"Staged: {len(status.staged_files)}")
+print(f"Modified: {len(status.modified_files)}")
+print(f"Untracked: {len(status.untracked_files)}")
+
+# Show diff (if any changes)
+if status.has_changes:
+    print("\n=== Diff ===")
+    diff = handler.show_diff()
+    if diff:
+        print(diff[:300] + "..." if len(diff) > 300 else diff)
+
+# Show recent commits
+print("\n=== Recent Commits ===")
+commits = handler.show_log(count=5)
+for c in commits:
+    print(f"  {c.short_hash} {c.message[:50]}")
+
+# To commit with AI message:
+# commit = handler.commit()  # Auto-generates message
+# commit = handler.commit(message="Custom message")
+
+# To undo last commit:
+# handler.undo(soft=True)  # Keeps changes staged

examples/python/cli/interactive_tui_example.py

@@ -0,0 +1,49 @@
+"""
+Interactive TUI Example for PraisonAI CLI.
+
+Rich terminal interface with completions and history.
+Docs: https://docs.praison.ai/cli/interactive-tui
+"""
+
+from praisonai.cli.features import InteractiveTUIHandler
+from praisonai.cli.features.interactive_tui import InteractiveConfig
+
+# Custom configuration
+config = InteractiveConfig(
+    prompt="ai> ",
+    multiline=True,
+    enable_completions=True,
+    show_status_bar=True
+)
+
+# Define callbacks
+def on_input(text):
+    """Handle regular input."""
+    return f"You said: {text}"
+
+def on_command(cmd):
+    """Handle slash commands."""
+    if cmd == "/exit":
+        return {"type": "exit"}
+    return {"type": "command", "message": f"Executed: {cmd}"}
+
+# Initialize
+handler = InteractiveTUIHandler()
+session = handler.initialize(
+    config=config,
+    on_input=on_input,
+    on_command=on_command
+)
+
+# Add commands for completion
+session.add_commands(["help", "exit", "cost", "model", "plan"])
+
+# Add symbols from codebase
+session.add_symbols(["MyClass", "my_function"])
+
+print("Interactive TUI initialized!")
+print("Commands available: /help, /exit, /cost, /model, /plan")
+print("Run handler.run() to start interactive session")
+
+# Uncomment to run interactive session:
+# handler.run()

examples/python/cli/repo_map_example.py

@@ -0,0 +1,24 @@
+"""
+Repository Map Example for PraisonAI CLI.
+
+Intelligent codebase mapping with symbol extraction.
+Docs: https://docs.praison.ai/cli/repo-map
+"""
+
+from praisonai.cli.features import RepoMapHandler
+
+# Initialize with current directory
+handler = RepoMapHandler(verbose=True)
+repo_map = handler.initialize(root=".")
+
+# Get the repository map
+print("=== Repository Map ===")
+map_str = handler.get_map()
+print(map_str[:500] if len(map_str) > 500 else map_str)
+print("..." if len(map_str) > 500 else "")
+
+# Refresh after file changes
+handler.refresh()
+
+# Get symbols for a specific file (if exists)
+# symbols = handler.get_context("MyClass")

examples/python/cli/sandbox_execution_example.py

@@ -0,0 +1,42 @@
+"""
+Sandbox Execution Example for PraisonAI CLI.
+
+Secure isolated command execution (--sandbox flag).
+Docs: https://docs.praison.ai/cli/sandbox-execution
+"""
+
+from praisonai.cli.features import SandboxExecutorHandler
+from praisonai.cli.features.sandbox_executor import SandboxMode
+
+# Initialize with basic sandbox
+handler = SandboxExecutorHandler(verbose=True)
+sandbox = handler.initialize(mode="basic")
+
+print(f"Sandbox mode: {handler.get_mode()}")
+print(f"Sandbox enabled: {handler.is_enabled}")
+
+# Execute a safe command
+print("\n=== Safe Command ===")
+result = handler.execute("echo 'Hello from sandbox!'")
+print(f"Success: {result.success}")
+print(f"Output: {result.stdout.strip()}")
+print(f"Sandboxed: {result.was_sandboxed}")
+
+# Try a blocked command
+print("\n=== Blocked Command ===")
+result = handler.execute("rm -rf /")
+print(f"Success: {result.success}")
+print(f"Violations: {result.policy_violations}")
+
+# Validate command before execution
+print("\n=== Command Validation ===")
+violations = handler.validate_command("sudo apt install something")
+if violations:
+    print(f"Command blocked: {violations}")
+else:
+    print("Command allowed")
+
+# Available modes
+print("\n=== Available Modes ===")
+for mode in SandboxMode:
+    print(f"  {mode.value}")

examples/python/cli/slash_commands_example.py

@@ -0,0 +1,51 @@
+"""
+Slash Commands Example for PraisonAI CLI.
+
+Demonstrates interactive slash commands like /help, /cost, /model.
+Docs: https://docs.praison.ai/cli/slash-commands
+"""
+
+from praisonai.cli.features import SlashCommandHandler
+from praisonai.cli.features.slash_commands import SlashCommand, CommandKind
+
+# Create handler
+handler = SlashCommandHandler()
+
+# Execute commands
+print("=== /help ===")
+result = handler.execute("/help")
+print(result.get("message", ""))
+
+print("\n=== /cost ===")
+result = handler.execute("/cost")
+print(result.get("message", ""))
+
+print("\n=== /model ===")
+result = handler.execute("/model")
+print(result.get("message", ""))
+
+# Check if input is a command
+print("\n=== Command Detection ===")
+print(f"/help is command: {handler.is_command('/help')}")
+print(f"hello is command: {handler.is_command('hello')}")
+
+# Get completions for auto-complete
+print("\n=== Completions for '/he' ===")
+completions = handler.get_completions("/he")
+print(completions)
+
+# Register custom command
+def my_custom_handler(args, context):
+    return {"type": "custom", "message": f"Custom command with args: {args}"}
+
+custom_cmd = SlashCommand(
+    name="mycommand",
+    description="My custom command",
+    handler=my_custom_handler,
+    kind=CommandKind.ACTION,
+    aliases=["mc"]
+)
+
+handler.register(custom_cmd)
+result = handler.execute("/mycommand arg1 arg2")
+print(f"\n=== Custom Command ===\n{result.get('message', '')}")

examples/python/code/claude_code_example.py

@@ -0,0 +1,34 @@
+"""
+Claude Code CLI Integration Example
+
+Demonstrates how to use Claude Code CLI as an agent tool in PraisonAI.
+"""
+
+import asyncio
+from praisonai.integrations import ClaudeCodeIntegration
+
+async def main():
+    # Create Claude Code integration
+    claude = ClaudeCodeIntegration(
+        workspace=".",
+        output_format="json",
+        skip_permissions=True,
+        system_prompt="Be concise and follow best practices",
+        allowed_tools=["Read", "Write", "Bash"]
+    )
+    
+    # Check availability
+    print(f"Claude CLI available: {claude.is_available}")
+    print(f"Claude SDK available: {claude.sdk_available}")
+    
+    # Execute a coding task
+    result = await claude.execute("List all Python files in the current directory")
+    print(f"Result: {result}")
+    
+    # Stream output
+    print("\nStreaming output:")
+    async for event in claude.stream("Explain the project structure"):
+        print(event)
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/python/code/code_editing_example.py

@@ -0,0 +1,60 @@
+"""
+Code Editing Tools Example
+
+Demonstrates how to use PraisonAI's code editing tools with SEARCH/REPLACE diffs.
+"""
+
+from praisonai.code import (
+    set_workspace,
+    code_read_file,
+    code_write_file,
+    code_apply_diff,
+    code_list_files,
+    code_execute_command,
+    CODE_TOOLS
+)
+
+# Set workspace
+set_workspace(".")
+
+# List files
+print("Files in current directory:")
+files = code_list_files(".", recursive=False)
+for f in files:
+    print(f"  {f}")
+
+# Read a file
+print("\nReading example file:")
+try:
+    content = code_read_file("README.md", start_line=1, end_line=10)
+    print(content)
+except Exception as e:
+    print(f"  File not found: {e}")
+
+# Write a file
+print("\nWriting test file:")
+code_write_file("test_output.txt", "Hello from PraisonAI Code Tools!")
+print("  Created test_output.txt")
+
+# Apply a diff
+print("\nApplying diff:")
+diff = """
+<<<<<<< SEARCH
+Hello from PraisonAI Code Tools!
+=======
+Hello from PraisonAI Code Tools!
+This line was added by a diff.
+>>>>>>> REPLACE
+"""
+result = code_apply_diff("test_output.txt", diff)
+print(f"  {result}")
+
+# Execute command
+print("\nExecuting command:")
+output = code_execute_command("cat test_output.txt")
+print(f"  {output}")
+
+# Cleanup
+import os
+os.remove("test_output.txt")
+print("\nCleanup complete.")

examples/python/code/codex_cli_example.py

@@ -0,0 +1,36 @@
+"""
+Codex CLI Integration Example
+
+Demonstrates how to use OpenAI Codex CLI as an agent tool in PraisonAI.
+"""
+
+import asyncio
+from praisonai.integrations import CodexCLIIntegration
+
+async def main():
+    # Create Codex CLI integration
+    codex = CodexCLIIntegration(
+        workspace=".",
+        full_auto=True,
+        sandbox="danger-full-access",
+        json_output=True
+    )
+    
+    # Check availability
+    print(f"Codex CLI available: {codex.is_available}")
+    print(f"Full Auto: {codex.full_auto}")
+    print(f"Sandbox: {codex.sandbox}")
+    
+    # Execute a coding task
+    result = await codex.execute("List files in the current directory")
+    print(f"Result: {result}")
+    
+    # Stream JSON events
+    print("\nStreaming events:")
+    async for event in codex.stream("Explain the project"):
+        event_type = event.get("type", "")
+        if event_type == "item.completed":
+            print(f"  {event}")
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/python/code/cursor_cli_example.py

@@ -0,0 +1,37 @@
+"""
+Cursor CLI Integration Example
+
+Demonstrates how to use Cursor CLI as an agent tool in PraisonAI.
+"""
+
+import asyncio
+from praisonai.integrations import CursorCLIIntegration
+
+async def main():
+    # Create Cursor CLI integration
+    cursor = CursorCLIIntegration(
+        workspace=".",
+        output_format="json",
+        force=True,
+        model="gpt-5",
+        stream_partial=True
+    )
+    
+    # Check availability
+    print(f"Cursor CLI available: {cursor.is_available}")
+    print(f"Force mode: {cursor.force}")
+    print(f"Model: {cursor.model}")
+    
+    # Execute a coding task
+    result = await cursor.execute("List files in the current directory")
+    print(f"Result: {result}")
+    
+    # Stream output
+    print("\nStreaming output:")
+    async for event in cursor.stream("Explain the project"):
+        content = event.get("content", "")
+        if content:
+            print(content, end="", flush=True)
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/python/code/external_agents_example.py

@@ -0,0 +1,58 @@
+"""
+External Agents Integration Example
+
+Demonstrates how to use all external CLI integrations as agent tools.
+"""
+
+import asyncio
+from praisonai.integrations import (
+    ClaudeCodeIntegration,
+    GeminiCLIIntegration,
+    CodexCLIIntegration,
+    CursorCLIIntegration,
+    get_available_integrations
+)
+
+async def main():
+    # Check availability of all integrations
+    print("=== External CLI Integrations ===\n")
+    
+    availability = get_available_integrations()
+    print("Availability:")
+    for name, avail in availability.items():
+        status = "✅" if avail else "❌"
+        print(f"  {status} {name}")
+    
+    # Create integrations
+    print("\n--- Claude Code ---")
+    claude = ClaudeCodeIntegration(workspace=".", skip_permissions=True)
+    print(f"CLI: {claude.cli_command}")
+    print(f"Available: {claude.is_available}")
+    tool = claude.as_tool()
+    print(f"Tool: {tool.__name__}")
+    
+    print("\n--- Gemini CLI ---")
+    gemini = GeminiCLIIntegration(workspace=".", model="gemini-2.5-flash")
+    print(f"CLI: {gemini.cli_command}")
+    print(f"Available: {gemini.is_available}")
+    tool = gemini.as_tool()
+    print(f"Tool: {tool.__name__}")
+    
+    print("\n--- Codex CLI ---")
+    codex = CodexCLIIntegration(workspace=".", full_auto=True)
+    print(f"CLI: {codex.cli_command}")
+    print(f"Available: {codex.is_available}")
+    tool = codex.as_tool()
+    print(f"Tool: {tool.__name__}")
+    
+    print("\n--- Cursor CLI ---")
+    cursor = CursorCLIIntegration(workspace=".", force=True)
+    print(f"CLI: {cursor.cli_command}")
+    print(f"Available: {cursor.is_available}")
+    tool = cursor.as_tool()
+    print(f"Tool: {tool.__name__}")
+    
+    print("\n=== All integrations ready ===")
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/python/code/gemini_cli_example.py

@@ -0,0 +1,33 @@
+"""
+Gemini CLI Integration Example
+
+Demonstrates how to use Gemini CLI as an agent tool in PraisonAI.
+"""
+
+import asyncio
+from praisonai.integrations import GeminiCLIIntegration
+
+async def main():
+    # Create Gemini CLI integration
+    gemini = GeminiCLIIntegration(
+        workspace=".",
+        model="gemini-2.5-flash",
+        output_format="json",
+        include_directories=["../lib", "../docs"]
+    )
+    
+    # Check availability
+    print(f"Gemini CLI available: {gemini.is_available}")
+    print(f"Model: {gemini.model}")
+    
+    # Execute a coding task
+    result = await gemini.execute("Analyze the code structure")
+    print(f"Result: {result}")
+    
+    # Execute with stats
+    result, stats = await gemini.execute_with_stats("Explain main.py")
+    print(f"Result: {result}")
+    print(f"Stats: {stats}")
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/python/scheduled_agents/news_checker_agent.py

@@ -0,0 +1,115 @@
+"""
+24/7 News Checker Agent Example
+
+This example demonstrates how to create a continuously running agent
+that checks for AI news every hour and prints the results.
+
+Usage:
+    python news_checker_agent.py
+    
+The agent will:
+1. Run immediately on start
+2. Check for latest AI news every 1 hour
+3. Print results to console
+4. Continue running until stopped (Ctrl+C)
+"""
+
+import os
+import sys
+from datetime import datetime
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../..'))
+
+from praisonaiagents import Agent
+from praisonai.agent_scheduler import AgentScheduler
+from tools import search_tool
+
+
+def on_success(result):
+    """Callback function called when agent execution succeeds."""
+    print("\n" + "="*80)
+    print(f"✅ SUCCESS - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("="*80)
+    print(result)
+    print("="*80 + "\n")
+
+
+def on_failure(error):
+    """Callback function called when agent execution fails."""
+    print("\n" + "="*80)
+    print(f"❌ FAILURE - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("="*80)
+    print(f"Error: {error}")
+    print("="*80 + "\n")
+
+
+def main():
+    """Main function to set up and run the scheduled news checker agent."""
+    
+    print("\n🤖 Starting 24/7 News Checker Agent")
+    print("="*80)
+    
+    # Create the agent with web search capability
+    agent = Agent(
+        name="NewsChecker",
+        role="AI News Monitor",
+        goal="Monitor and summarize the latest AI and technology news",
+        backstory="""You are an expert AI news analyst who stays up-to-date 
+        with the latest developments in artificial intelligence, machine learning, 
+        and technology. You provide concise, accurate summaries of important news.""",
+        tools=[search_tool],
+        verbose=True
+    )
+    
+    # Define the task
+    task = """Search for the latest AI news from today. 
+    Focus on major developments, breakthroughs, or announcements.
+    Provide a summary of the top 3-5 most important news items.
+    Include the source and key details for each item."""
+    
+    # Create scheduler with callbacks
+    scheduler = AgentScheduler(
+        agent=agent,
+        task=task,
+        on_success=on_success,
+        on_failure=on_failure
+    )
+    
+    print(f"Agent: {agent.name}")
+    print(f"Task: {task}")
+    print(f"Schedule: Every 1 hour")
+    print("="*80)
+    print("\n⏰ Starting scheduler... (Press Ctrl+C to stop)\n")
+    
+    # Start the scheduler
+    # - "hourly" or "*/1h" = every 1 hour
+    # - run_immediately=True = run once before starting the schedule
+    scheduler.start(
+        schedule_expr="hourly",  # Run every hour
+        max_retries=3,           # Retry up to 3 times on failure
+        run_immediately=True     # Run immediately on start
+    )
+    
+    try:
+        # Keep the main thread alive
+        while scheduler.is_running:
+            import time
+            time.sleep(1)
+            
+    except KeyboardInterrupt:
+        print("\n\n🛑 Stopping scheduler...")
+        scheduler.stop()
+        
+        # Print final statistics
+        stats = scheduler.get_stats()
+        print("\n📊 Final Statistics:")
+        print(f"  Total Executions: {stats['total_executions']}")
+        print(f"  Successful: {stats['successful_executions']}")
+        print(f"  Failed: {stats['failed_executions']}")
+        print(f"  Success Rate: {stats['success_rate']:.1f}%")
+        print("\n✅ Agent stopped successfully\n")
+
+
+if __name__ == "__main__":
+    main()

examples/python/scheduled_agents/news_checker_live.py

@@ -0,0 +1,143 @@
+"""
+Live News Checker Agent - 24/7 Scheduled Agent
+
+This example demonstrates a real working agent that checks AI news
+every hour using the AgentScheduler with actual API calls.
+
+Requirements:
+    - OPENAI_API_KEY environment variable set
+    - praisonaiagents package installed
+    
+Usage:
+    python news_checker_live.py
+"""
+
+import os
+import sys
+from datetime import datetime
+
+# Add parent directory to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../..'))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../../..'))
+
+from praisonaiagents import Agent
+from praisonai.scheduler import AgentScheduler
+
+# Import search_tool from root tools.py
+try:
+    from tools import search_tool
+except ImportError:
+    # Fallback: create inline search tool
+    from duckduckgo_search import DDGS
+    
+    def search_tool(query: str) -> list:
+        """Search the web using DuckDuckGo."""
+        try:
+            results = []
+            ddgs = DDGS()
+            for result in ddgs.text(keywords=query, max_results=5):
+                results.append({
+                    "title": result.get("title", ""),
+                    "url": result.get("href", ""),
+                    "snippet": result.get("body", ""),
+                })
+            return results
+        except Exception as e:
+            print(f"Search error: {e}")
+            return []
+
+
+def on_success(result):
+    """Callback when agent execution succeeds."""
+    print("\n" + "="*80)
+    print(f"✅ SUCCESS - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("="*80)
+    print(result)
+    print("="*80 + "\n")
+
+
+def on_failure(error):
+    """Callback when agent execution fails."""
+    print("\n" + "="*80)
+    print(f"❌ FAILURE - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("="*80)
+    print(f"Error: {error}")
+    print("="*80 + "\n")
+
+
+def main():
+    """Main function to run the scheduled news checker."""
+    
+    # Check for API key
+    if not os.getenv("OPENAI_API_KEY"):
+        print("❌ Error: OPENAI_API_KEY environment variable not set")
+        print("Please set it with: export OPENAI_API_KEY=your_key_here")
+        sys.exit(1)
+    
+    print("\n🤖 Starting 24/7 AI News Checker Agent")
+    print("="*80)
+    
+    # Create the agent with web search capability
+    agent = Agent(
+        name="AI News Monitor",
+        role="Technology News Analyst",
+        goal="Monitor and summarize the latest AI and technology news",
+        backstory="""You are an expert AI news analyst who stays up-to-date 
+        with the latest developments in artificial intelligence, machine learning, 
+        and technology. You provide concise, accurate summaries of important news.""",
+        tools=[search_tool],
+        verbose=True,
+        self_reflect=False  # Disable reflection for faster execution
+    )
+    
+    # Define the task
+    task = """Search for the latest AI news from today. 
+    Focus on major developments, breakthroughs, or announcements.
+    Provide a summary of the top 3 most important news items.
+    Include the source and key details for each item."""
+    
+    # Create scheduler with callbacks
+    scheduler = AgentScheduler(
+        agent=agent,
+        task=task,
+        on_success=on_success,
+        on_failure=on_failure
+    )
+    
+    print(f"Agent: {agent.name}")
+    print(f"Task: {task}")
+    print(f"Schedule: Every 1 hour")
+    print("="*80)
+    print("\n⏰ Starting scheduler... (Press Ctrl+C to stop)\n")
+    
+    # Start the scheduler
+    # For testing: use "*/2m" (every 2 minutes) instead of "hourly"
+    # For production: use "hourly"
+    scheduler.start(
+        schedule_expr="*/2m",  # Every 2 minutes for testing
+        max_retries=3,
+        run_immediately=True  # Run once immediately
+    )
+    
+    try:
+        # Keep the main thread alive
+        while scheduler.is_running:
+            import time
+            time.sleep(1)
+            
+    except KeyboardInterrupt:
+        print("\n\n🛑 Stopping scheduler...")
+        scheduler.stop()
+        
+        # Print final statistics
+        stats = scheduler.get_stats()
+        print("\n📊 Final Statistics:")
+        print(f"  Total Executions: {stats['total_executions']}")
+        print(f"  Successful: {stats['successful_executions']}")
+        print(f"  Failed: {stats['failed_executions']}")
+        print(f"  Success Rate: {stats['success_rate']:.1f}%")
+        print("\n✅ Agent stopped successfully\n")
+
+
+if __name__ == "__main__":
+    main()

examples/python/scheduled_agents/simple_test.py

@@ -0,0 +1,61 @@
+"""
+Simple test script for 24/7 Agent Scheduler
+
+This script demonstrates the basic usage of AgentScheduler
+for running agents periodically.
+
+Usage:
+    python simple_test.py
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../..'))
+
+from unittest.mock import Mock
+from praisonai.scheduler import AgentScheduler
+
+# Create a mock agent for testing
+mock_agent = Mock()
+mock_agent.name = "TestAgent"
+mock_agent.start = Mock(return_value="Test execution successful!")
+
+# Create scheduler
+scheduler = AgentScheduler(
+    agent=mock_agent,
+    task="Test task execution"
+)
+
+print("🤖 Testing AgentScheduler")
+print("=" * 60)
+
+# Test 1: Execute once
+print("\n✅ Test 1: Execute once")
+result = scheduler.execute_once()
+print(f"Result: {result}")
+
+# Test 2: Get stats
+print("\n✅ Test 2: Get statistics")
+stats = scheduler.get_stats()
+print(f"Stats: {stats}")
+
+# Test 3: Start scheduler (will run every 5 seconds)
+print("\n✅ Test 3: Start scheduler (*/5s)")
+scheduler.start("*/5s", run_immediately=True)
+
+import time
+print("Running for 12 seconds...")
+time.sleep(12)
+
+# Stop scheduler
+print("\n✅ Test 4: Stop scheduler")
+scheduler.stop()
+
+# Final stats
+print("\n📊 Final Statistics:")
+final_stats = scheduler.get_stats()
+for key, value in final_stats.items():
+    print(f"  {key}: {value}")
+
+print("\n✅ All tests passed!")
+print("=" * 60)

src/praisonai-agents/praisonaiagents/_logging.py

@@ -55,10 +55,10 @@ def _get_all_noisy_loggers() -> List[str]:
 
 def _configure_loggers():
     """Configure all loggers based on LOGLEVEL environment variable."""
-    loglevel = os.environ.get('LOGLEVEL', 'INFO').upper()
+    loglevel = os.environ.get('LOGLEVEL', 'WARNING').upper()
     
-    # When DEBUG is set, allow some HTTP logging for API endpoints
-    if loglevel == 'DEBUG':
+    # When DEBUG or INFO is set, allow some HTTP logging for API endpoints
+    if loglevel in ('DEBUG', 'INFO'):
         allowed_debug_loggers = {"httpx", "httpx._client", "openai._client"}
         
         for logger_name in _get_all_noisy_loggers():
@@ -109,10 +109,10 @@ def configure_root_logger():
     """Configure the root logger with RichHandler."""
     from rich.logging import RichHandler
     
-    loglevel = os.environ.get('LOGLEVEL', 'INFO').upper()
+    loglevel = os.environ.get('LOGLEVEL', 'WARNING').upper()
     
     logging.basicConfig(
-        level=getattr(logging, loglevel, logging.INFO),
+        level=getattr(logging, loglevel, logging.WARNING),
         format="%(asctime)s %(filename)s:%(lineno)d %(levelname)s %(message)s",
         datefmt="[%X]",
         handlers=[RichHandler(rich_tracebacks=True)],

src/praisonai-agents/praisonaiagents/_warning_patch.py

@@ -29,7 +29,9 @@ SUPPRESSED_PATTERNS = [
     "PydanticSerializationUnexpectedValue",
     "Expected 9 fields but got 5 for type `Message`",
     "Expected `StreamingChoices` but got `Choices`",
-    "serialized value may not be as expected"
+    "serialized value may not be as expected",
+    "Mixing V1 models and V2 models",
+    "Please upgrade `Settings` to V2"
 ]
 
 @functools.wraps(_original_warn)

src/praisonai-agents/praisonaiagents/agent/agent.py

@@ -1538,13 +1538,13 @@ Your Goal: {self.goal}"""
         logging.debug(f"{self.name} executing tool {function_name} with arguments: {arguments}")
 
         # Check if approval is required for this tool
-        from ..approval import is_approval_required, console_approval_callback, get_risk_level, mark_approved, ApprovalDecision
+        from ..approval import is_approval_required, console_approval_callback, get_risk_level, mark_approved, ApprovalDecision, get_approval_callback
         if is_approval_required(function_name):
             risk_level = get_risk_level(function_name)
-            logging.info(f"Tool {function_name} requires approval (risk level: {risk_level})")
+            logging.debug(f"Tool {function_name} requires approval (risk level: {risk_level})")
             
             # Use global approval callback or default console callback
-            callback = approval_callback or console_approval_callback
+            callback = get_approval_callback() or console_approval_callback
             
             try:
                 decision = callback(function_name, arguments, risk_level)

src/praisonai-agents/praisonaiagents/approval.py

@@ -43,6 +43,15 @@ def set_approval_callback(callback_fn: Callable):
     global approval_callback
     approval_callback = callback_fn
 
+def get_approval_callback() -> Optional[Callable]:
+    """Get the current approval callback function.
+    
+    Returns the custom callback if set, otherwise None.
+    This should be used instead of directly accessing approval_callback
+    to ensure the latest callback is always used.
+    """
+    return approval_callback
+
 def mark_approved(tool_name: str):
     """Mark a tool as approved in the current context."""
     approved = _approved_context.get(set())
@@ -90,7 +99,7 @@ def require_approval(risk_level: RiskLevel = "high"):
             except Exception as e:
                 # Fallback to sync approval if async fails
                 logging.warning(f"Async approval failed, using sync fallback: {e}")
-                callback = approval_callback or console_approval_callback
+                callback = get_approval_callback() or console_approval_callback
                 decision = callback(tool_name, kwargs, risk_level)
             
             if not decision.approved:
@@ -198,7 +207,7 @@ async def request_approval(function_name: str, arguments: Dict[str, Any]) -> App
     risk_level = TOOL_RISK_LEVELS.get(function_name, "medium")
     
     # Use custom callback if set, otherwise use console callback
-    callback = approval_callback or console_approval_callback
+    callback = get_approval_callback() or console_approval_callback
     
     try:
         # Handle async callbacks

src/praisonai-agents/praisonaiagents/llm/llm.py

@@ -1054,7 +1054,7 @@ class LLM:
         **kwargs
     ) -> str:
         """Enhanced get_response with all OpenAI-like features"""
-        logging.info(f"Getting response from {self.model}")
+        logging.debug(f"Getting response from {self.model}")
         # Log all self values when in debug mode
         self._log_llm_config(
             'LLM instance',
@@ -2472,7 +2472,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         """Async version of get_response with identical functionality."""
         try:
             import litellm
-            logging.info(f"Getting async response from {self.model}")
+            logging.debug(f"Getting async response from {self.model}")
             # Log all self values when in debug mode
             self._log_llm_config(
                 'get_response_async',

src/praisonai-agents/praisonaiagents/llm/openai_client.py

@@ -19,6 +19,15 @@ from rich.console import Console
 from rich.live import Live
 import inspect
 
+# Import display_tool_call for callback support (lazy import to avoid circular imports)
+_display_tool_call = None
+def _get_display_tool_call():
+    global _display_tool_call
+    if _display_tool_call is None:
+        from ..main import display_tool_call
+        _display_tool_call = display_tool_call
+    return _display_tool_call
+
 # Constants
 LOCAL_SERVER_API_KEY_PLACEHOLDER = "not-needed"
 
@@ -978,16 +987,19 @@ class OpenAIClient:
                         function_name = tool_call.function.name
                         arguments = json.loads(tool_call.function.arguments)
                     
+                    # Always trigger callback for tool call tracking (even when verbose=False)
+                    display_tool_call_fn = _get_display_tool_call()
+                    display_tool_call_fn(f"Calling function: {function_name}", console=console if verbose else None)
+                    
                     if verbose and console:
-                        console.print(f"[bold]Calling function:[/bold] {function_name}")
                         console.print(f"[dim]Arguments:[/dim] {arguments}")
                     
                     # Execute the tool
                     tool_result = execute_tool_fn(function_name, arguments)
                     results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
                     
-                    if verbose and console:
-                        console.print(f"[dim]Result:[/dim] {results_str}")
+                    # Trigger callback with result
+                    display_tool_call_fn(f"Function {function_name} returned: {results_str[:200]}{'...' if len(results_str) > 200 else ''}", console=console if verbose else None)
                     
                     messages.append({
                         "role": "tool",
@@ -1150,8 +1162,11 @@ class OpenAIClient:
                         function_name = tool_call.function.name
                         arguments = json.loads(tool_call.function.arguments)
                     
+                    # Always trigger callback for tool call tracking (even when verbose=False)
+                    display_tool_call_fn = _get_display_tool_call()
+                    display_tool_call_fn(f"Calling function: {function_name}", console=console if verbose else None)
+                    
                     if verbose and console:
-                        console.print(f"[bold]Calling function:[/bold] {function_name}")
                         console.print(f"[dim]Arguments:[/dim] {arguments}")
                     
                     # Execute the tool (async)
@@ -1167,8 +1182,8 @@ class OpenAIClient:
                     
                     results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
                     
-                    if verbose and console:
-                        console.print(f"[dim]Result:[/dim] {results_str}")
+                    # Trigger callback with result
+                    display_tool_call_fn(f"Function {function_name} returned: {results_str[:200]}{'...' if len(results_str) > 200 else ''}", console=console if verbose else None)
                     
                     messages.append({
                         "role": "tool",
@@ -1299,6 +1314,10 @@ class OpenAIClient:
                                 yield f"\n[Error parsing arguments for {function_name if 'function_name' in locals() else 'unknown function'}: {str(e)}]"
                             continue
                         
+                        # Always trigger callback for tool call tracking (even when verbose=False)
+                        display_tool_call_fn = _get_display_tool_call()
+                        display_tool_call_fn(f"Calling function: {function_name}", console=None)
+                        
                         if verbose:
                             yield f"\n[Calling function: {function_name}]"
                         
@@ -1311,6 +1330,9 @@ class OpenAIClient:
                             if verbose:
                                 yield f"\n[Function error: {str(e)}]"
                         
+                        # Trigger callback with result
+                        display_tool_call_fn(f"Function {function_name} returned: {results_str[:200]}{'...' if len(results_str) > 200 else ''}", console=None)
+                        
                         if verbose:
                             yield f"\n[Function result: {results_str}]"
                         

src/praisonai-agents/praisonaiagents/main.py

@@ -231,15 +231,15 @@ def display_tool_call(message: str, console=None):
     if not message or not message.strip():
         logging.debug("Empty message in display_tool_call, returning early")
         return
-    if console is None:
-        console = Console()
     message = _clean_display_content(str(message))
     logging.debug(f"Cleaned message in display_tool_call: {repr(message)}")
     
-    # Execute synchronous callbacks
+    # Execute synchronous callbacks (always, even when console is None)
     execute_sync_callback('tool_call', message=message)
     
-    console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
+    # Only print panel if console is provided (verbose mode)
+    if console is not None:
+        console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
 
 def display_error(message: str, console=None):
     if not message or not message.strip():

src/praisonai-agents/praisonaiagents/tools/mentions.py

@@ -14,6 +14,7 @@ Usage:
     context, cleaned_prompt = parser.process("@file:main.py explain this code")
 """
 
+import os
 import re
 import logging
 from pathlib import Path
@@ -43,10 +44,14 @@ class MentionsParser:
         "url": re.compile(r'@url:(https?://[^\s]+)'),
     }
     
+    # Default max file chars: 500K (~125K tokens) - fits GPT-4o (128K), Claude 3.5 (200K)
+    DEFAULT_MAX_FILE_CHARS = 500000
+    
     def __init__(
         self,
         workspace_path: Optional[str] = None,
-        verbose: int = 0
+        verbose: int = 0,
+        max_file_chars: Optional[int] = None
     ):
         """
         Initialize MentionsParser.
@@ -54,10 +59,24 @@ class MentionsParser:
         Args:
             workspace_path: Path to workspace/project root
             verbose: Verbosity level
+            max_file_chars: Maximum characters to include from files.
+                           Default: 500000 (500K chars, ~125K tokens).
+                           Set to 0 for no limit.
+                           Can be overridden via PRAISON_MAX_FILE_CHARS env var.
         """
         self.workspace_path = Path(workspace_path) if workspace_path else Path.cwd()
         self.verbose = verbose
         
+        # Configure max file chars: constructor > env var > default
+        if max_file_chars is not None:
+            self.max_file_chars = max_file_chars
+        else:
+            env_val = os.environ.get('PRAISON_MAX_FILE_CHARS')
+            if env_val is not None:
+                self.max_file_chars = int(env_val)
+            else:
+                self.max_file_chars = self.DEFAULT_MAX_FILE_CHARS
+        
         # Lazy-loaded managers
         self._docs_manager = None
         self._rules_manager = None
@@ -158,9 +177,15 @@ class MentionsParser:
             
             content = full_path.read_text(encoding="utf-8")
             
-            # Limit content size
-            if len(content) > 50000:
-                content = content[:50000] + "\n... (truncated)"
+            # Limit content size (0 means no limit)
+            if self.max_file_chars > 0 and len(content) > self.max_file_chars:
+                original_size = len(content)
+                content = content[:self.max_file_chars] + "\n... (truncated)"
+                self._log(
+                    f"File {file_path} truncated from {original_size:,} to {self.max_file_chars:,} chars. "
+                    f"Set PRAISON_MAX_FILE_CHARS=0 for no limit.",
+                    logging.WARNING
+                )
             
             # Detect language for code fence
             ext = full_path.suffix.lower()
@@ -253,9 +278,9 @@ class MentionsParser:
             with urllib.request.urlopen(req, timeout=10) as response:
                 content = response.read().decode('utf-8', errors='ignore')
             
-            # Limit content size
-            if len(content) > 50000:
-                content = content[:50000] + "\n... (truncated)"
+            # Limit content size (0 means no limit)
+            if self.max_file_chars > 0 and len(content) > self.max_file_chars:
+                content = content[:self.max_file_chars] + "\n... (truncated)"
             
             # Try to extract text from HTML
             if '<html' in content.lower():

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.1.17"
+version = "0.1.21"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 readme = "README.md"
 requires-python = ">=3.10"

src/praisonai-agents/tests/test_mentions_configurable_limit.py

@@ -0,0 +1,217 @@
+"""
+Unit tests for configurable max_file_chars in MentionsParser.
+
+TDD approach: Write tests first, then implement.
+"""
+
+import os
+import pytest
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+
+class TestMentionsParserConfigurableLimit:
+    """Test suite for configurable file truncation limit."""
+    
+    @pytest.fixture
+    def temp_workspace(self):
+        """Create a temporary workspace with test files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            yield Path(tmpdir)
+    
+    @pytest.fixture
+    def small_file(self, temp_workspace):
+        """Create a small test file (1KB)."""
+        file_path = temp_workspace / "small.py"
+        content = "# Small file\n" + "x = 1\n" * 100  # ~700 chars
+        file_path.write_text(content)
+        return file_path
+    
+    @pytest.fixture
+    def large_file(self, temp_workspace):
+        """Create a large test file (100KB)."""
+        file_path = temp_workspace / "large.py"
+        content = "# Large file\n" + "x = 'a' * 100\n" * 7000  # ~100KB
+        file_path.write_text(content)
+        return file_path
+    
+    @pytest.fixture
+    def huge_file(self, temp_workspace):
+        """Create a huge test file (600KB)."""
+        file_path = temp_workspace / "huge.py"
+        content = "# Huge file\n" + "x = 'a' * 100\n" * 42000  # ~600KB
+        file_path.write_text(content)
+        return file_path
+
+    # ===== Test 1.1: Default value (500K) =====
+    def test_default_max_file_chars_is_500k(self, temp_workspace):
+        """Default max_file_chars should be 500,000."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        
+        parser = MentionsParser(workspace_path=str(temp_workspace))
+        assert parser.max_file_chars == 500000
+    
+    # ===== Test 1.2: Custom value via constructor =====
+    def test_custom_max_file_chars_via_constructor(self, temp_workspace):
+        """max_file_chars should be configurable via constructor."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        
+        parser = MentionsParser(
+            workspace_path=str(temp_workspace),
+            max_file_chars=100000
+        )
+        assert parser.max_file_chars == 100000
+    
+    def test_custom_max_file_chars_zero_means_no_limit(self, temp_workspace):
+        """max_file_chars=0 should mean no truncation."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        
+        parser = MentionsParser(
+            workspace_path=str(temp_workspace),
+            max_file_chars=0
+        )
+        assert parser.max_file_chars == 0
+    
+    # ===== Test 1.3: Environment variable override =====
+    def test_env_var_override(self, temp_workspace):
+        """PRAISON_MAX_FILE_CHARS env var should override default."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        
+        with patch.dict(os.environ, {'PRAISON_MAX_FILE_CHARS': '200000'}):
+            # Need to reimport to pick up env var
+            parser = MentionsParser(workspace_path=str(temp_workspace))
+            assert parser.max_file_chars == 200000
+    
+    def test_constructor_takes_precedence_over_env_var(self, temp_workspace):
+        """Constructor value should take precedence over env var."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        
+        with patch.dict(os.environ, {'PRAISON_MAX_FILE_CHARS': '200000'}):
+            parser = MentionsParser(
+                workspace_path=str(temp_workspace),
+                max_file_chars=100000
+            )
+            assert parser.max_file_chars == 100000
+    
+    # ===== Test 1.4: No-limit mode =====
+    def test_no_truncation_when_limit_is_zero(self, temp_workspace, huge_file):
+        """File should not be truncated when max_file_chars=0."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        
+        parser = MentionsParser(
+            workspace_path=str(temp_workspace),
+            max_file_chars=0
+        )
+        
+        context, _ = parser.process(f"@file:{huge_file.name} explain")
+        
+        # Should contain full content, no truncation message
+        assert "(truncated)" not in context
+        # Should have the full file content
+        original_size = huge_file.read_text().__len__()
+        # Context includes header and code fence, so check it's close
+        assert len(context) >= original_size
+    
+    # ===== Test 1.5: Truncation behavior =====
+    def test_truncation_at_custom_limit(self, temp_workspace, large_file):
+        """File should be truncated at custom limit."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        
+        parser = MentionsParser(
+            workspace_path=str(temp_workspace),
+            max_file_chars=10000  # 10KB limit
+        )
+        
+        context, _ = parser.process(f"@file:{large_file.name} explain")
+        
+        # Should be truncated
+        assert "(truncated)" in context
+        # Content should be around the limit (plus header/fence overhead)
+        assert len(context) < 15000  # Some overhead for markdown
+    
+    def test_no_truncation_when_file_under_limit(self, temp_workspace, small_file):
+        """Small files should not be truncated."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        
+        parser = MentionsParser(
+            workspace_path=str(temp_workspace),
+            max_file_chars=500000
+        )
+        
+        context, _ = parser.process(f"@file:{small_file.name} explain")
+        
+        # Should NOT be truncated
+        assert "(truncated)" not in context
+    
+    def test_truncation_warning_logged(self, temp_workspace, large_file, caplog):
+        """Warning should be logged when file is truncated."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        import logging
+        
+        parser = MentionsParser(
+            workspace_path=str(temp_workspace),
+            max_file_chars=10000,
+            verbose=1
+        )
+        
+        with caplog.at_level(logging.WARNING):
+            parser.process(f"@file:{large_file.name} explain")
+        
+        # Should log a warning about truncation
+        assert any("truncat" in record.message.lower() for record in caplog.records)
+    
+    # ===== Test: URL truncation also uses configurable limit =====
+    def test_url_truncation_uses_same_limit(self, temp_workspace):
+        """URL content should also respect max_file_chars."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        
+        parser = MentionsParser(
+            workspace_path=str(temp_workspace),
+            max_file_chars=100000
+        )
+        
+        # URL truncation should use the same limit
+        assert parser.max_file_chars == 100000
+    
+    # ===== Test: Backward compatibility =====
+    def test_backward_compatible_no_args(self, temp_workspace):
+        """Parser should work without max_file_chars argument."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        
+        # Should not raise any errors
+        parser = MentionsParser(workspace_path=str(temp_workspace))
+        assert hasattr(parser, 'max_file_chars')
+    
+    # ===== Test: Performance - no impact on small files =====
+    def test_performance_small_file(self, temp_workspace, small_file):
+        """Processing small files should be fast."""
+        from praisonaiagents.tools.mentions import MentionsParser
+        import time
+        
+        parser = MentionsParser(workspace_path=str(temp_workspace))
+        
+        start = time.time()
+        for _ in range(100):
+            parser.process(f"@file:{small_file.name} explain")
+        elapsed = time.time() - start
+        
+        # 100 iterations should complete in under 1 second
+        assert elapsed < 1.0, f"Performance regression: {elapsed}s for 100 iterations"
+
+
+class TestProcessMentionsFunction:
+    """Test the convenience function."""
+    
+    def test_process_mentions_uses_default_limit(self):
+        """process_mentions function should use default limit."""
+        from praisonaiagents.tools.mentions import process_mentions
+        
+        # The function should create a parser with default settings
+        # Just verify it works without errors
+        context, cleaned = process_mentions("hello world")
+        assert cleaned == "hello world"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

src/praisonai-agents/uv.lock

@@ -2422,7 +2422,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.1.17"
+version = "0.1.21"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

src/praisonai/README.md

@@ -191,8 +191,14 @@ npm install praisonai
 | 📚 Add Custom Knowledge | [Example](examples/python/concepts/knowledge-agents.py) | [📖](https://docs.praison.ai/features/knowledge) |
 | 🧠 Memory (Short & Long Term) | [Example](examples/python/general/memory_example.py) | [📖](https://docs.praison.ai/concepts/memory) |
 | 📄 Chat with PDF Agents | [Example](examples/python/concepts/chat-with-pdf.py) | [📖](https://docs.praison.ai/features/chat-with-pdf) |
-| 💻 Code Interpreter Agents | [Example](examples/python/agents/code-agent.py) | [📖](https://docs.praison.ai/features/codeagent) |
-| ✏️ AI Code Editing Tools | [Example](#ai-code-editing) | [📖](https://docs.praison.ai/features/code) |
+| **💻 Code** | | |
+| ↳ Code Interpreter Agents | [Example](examples/python/agents/code-agent.py) | [📖](https://docs.praison.ai/features/codeagent) |
+| ↳ AI Code Editing Tools | [Example](examples/python/code/code_editing_example.py) | [📖](https://docs.praison.ai/code/editing) |
+| ↳ External Agents (All) | [Example](examples/python/code/external_agents_example.py) | [📖](https://docs.praison.ai/code/external-agents) |
+| ↳ Claude Code CLI | [Example](examples/python/code/claude_code_example.py) | [📖](https://docs.praison.ai/code/claude-code) |
+| ↳ Gemini CLI | [Example](examples/python/code/gemini_cli_example.py) | [📖](https://docs.praison.ai/code/gemini-cli) |
+| ↳ Codex CLI | [Example](examples/python/code/codex_cli_example.py) | [📖](https://docs.praison.ai/code/codex-cli) |
+| ↳ Cursor CLI | [Example](examples/python/code/cursor_cli_example.py) | [📖](https://docs.praison.ai/code/cursor-cli) |
 | 📚 RAG Agents | [Example](examples/python/concepts/rag-agents.py) | [📖](https://docs.praison.ai/features/rag) |
 | 🤔 Async & Parallel Processing | [Example](examples/python/general/async_example.py) | [📖](https://docs.praison.ai/features/async) |
 | 🔢 Math Agents | [Example](examples/python/agents/math-agent.py) | [📖](https://docs.praison.ai/features/mathagent) |
@@ -230,7 +236,7 @@ npm install praisonai
 | 💻 Programming Agent | [Example](examples/python/agents/programming-agent.py) | [📖](https://docs.praison.ai/agents/programming) |
 | 📝 Markdown Agent | [Example](examples/python/agents/markdown-agent.py) | [📖](https://docs.praison.ai/agents/markdown) |
 | 📝 Prompt Expander Agent | [Example](#prompt-expansion) | [📖](https://docs.praison.ai/agents/prompt-expander) |
-| 🔀 Router Agent | [Example](examples/python/agents/router-agent-cost-optimization.py) | [📖](https://docs.praison.ai/features/routing) |
+| 🔀 Model Router | [Example](examples/python/agents/router-agent-cost-optimization.py) | [📖](https://docs.praison.ai/features/model-router) |
 | ⛓️ Prompt Chaining | [Example](examples/python/general/prompt_chaining.py) | [📖](https://docs.praison.ai/features/promptchaining) |
 | 🔍 Evaluator Optimiser | [Example](examples/python/general/evaluator-optimiser.py) | [📖](https://docs.praison.ai/features/evaluator-optimiser) |
 | 👷 Orchestrator Workers | [Example](examples/python/general/orchestrator-workers.py) | [📖](https://docs.praison.ai/features/orchestrator-worker) |
@@ -246,12 +252,22 @@ npm install praisonai
 | 🪝 Hooks | [Example](#9-hooks) | [📖](https://docs.praison.ai/features/hooks) |
 | 📈 Telemetry | [Example](examples/python/telemetry/production-telemetry-example.py) | [📖](https://docs.praison.ai/features/telemetry) |
 | 📹 Camera Integration | [Example](examples/python/camera/) | [📖](https://docs.praison.ai/features/camera-integration) |
-| 📄 Project Docs (.praison/docs/) | [Example](#docs-cli) | [📖](https://docs.praison.ai/cli/docs) |
-| 🔌 MCP Config Management | [Example](#mcp-config-cli) | [📖](https://docs.praison.ai/cli/mcp) |
-| 💬 AI Commit Messages | [Example](#ai-commit-cli) | [📖](https://docs.praison.ai/cli/commit) |
-| @ @Mentions in Prompts | [Example](#mentions-in-prompts) | [📖](https://docs.praison.ai/cli/mentions) |
-| 💾 Auto-Save Sessions | [Example](#session-management-python) | [📖](https://docs.praison.ai/cli/session) |
-| 📜 History in Context | [Example](#session-management-python) | [📖](https://docs.praison.ai/cli/session) |
+| 📄 Project Docs (.praison/docs/) | [Example](#docs-cli) | [📖](https://docs.praison.ai/docs/cli/docs) |
+| 🔌 MCP Config Management | [Example](#mcp-config-cli) | [📖](https://docs.praison.ai/docs/cli/mcp) |
+| 💬 AI Commit Messages | [Example](#ai-commit-cli) | [📖](https://docs.praison.ai/docs/cli/commit) |
+| @ @Mentions in Prompts | [Example](#mentions-in-prompts) | [📖](https://docs.praison.ai/docs/cli/mentions) |
+| 💾 Auto-Save Sessions | [Example](#session-management-python) | [📖](https://docs.praison.ai/docs/cli/session) |
+| 📜 History in Context | [Example](#session-management-python) | [📖](https://docs.praison.ai/docs/cli/session) |
+| **🖥️ CLI Features** | | |
+| ↳ Slash Commands | [Example](examples/python/cli/slash_commands_example.py) | [📖](https://docs.praison.ai/docs/cli/slash-commands) |
+| ↳ Autonomy Modes | [Example](examples/python/cli/autonomy_modes_example.py) | [📖](https://docs.praison.ai/docs/cli/autonomy-modes) |
+| ↳ Cost Tracking | [Example](examples/python/cli/cost_tracking_example.py) | [📖](https://docs.praison.ai/docs/cli/cost-tracking) |
+| ↳ Repository Map | [Example](examples/python/cli/repo_map_example.py) | [📖](https://docs.praison.ai/docs/cli/repo-map) |
+| ↳ Interactive TUI | [Example](examples/python/cli/interactive_tui_example.py) | [📖](https://docs.praison.ai/docs/cli/interactive-tui) |
+| ↳ Git Integration | [Example](examples/python/cli/git_integration_example.py) | [📖](https://docs.praison.ai/docs/cli/git-integration) |
+| ↳ Sandbox Execution | [Example](examples/python/cli/sandbox_execution_example.py) | [📖](https://docs.praison.ai/docs/cli/sandbox-execution) |
+| **⏰ 24/7 Scheduling** | | |
+| ↳ Agent Scheduler | [Example](examples/python/scheduled_agents/news_checker_live.py) | [📖](https://docs.praison.ai/docs/cli/scheduler) |
 
 ---
 
@@ -958,6 +974,32 @@ export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
 praisonai --auto create a movie script about Robots in Mars
 ```
 
+### Interactive Mode CLI:
+```bash
+# Start interactive terminal mode (inspired by Gemini CLI, Codex CLI, Claude Code)
+praisonai --interactive
+praisonai -i
+
+# Features:
+# - Streaming responses (no boxes)
+# - Built-in tools: read_file, write_file, list_files, execute_command, internet_search
+# - Slash commands: /help, /exit, /tools, /clear
+
+# Chat mode - single prompt with interactive style (for testing/scripting)
+# Use --chat (or --chat-mode for backward compatibility)
+praisonai "list files in current folder" --chat
+praisonai "search the web for AI news" --chat
+praisonai "read README.md" --chat
+```
+
+### Chat UI (Web Interface):
+```bash
+# Start web-based Chainlit chat interface (requires praisonai[chat])
+pip install "praisonai[chat]"
+praisonai chat
+# Opens browser at http://localhost:8084
+```
+
 ### Query Rewriting (works with any command):
 ```bash
 # Rewrite query for better results (uses QueryRewriterAgent)
@@ -1018,6 +1060,20 @@ praisonai "Complex analysis task" --planning --planning-reasoning
 praisonai "Task" --planning --auto-approve-plan
 ```
 
+### Tool Approval CLI:
+```bash
+# Auto-approve ALL tool executions (use with caution!)
+praisonai "run ls command" --trust
+
+# Auto-approve tools up to a risk level (prompt for higher)
+# Levels: low, medium, high, critical
+praisonai "write to file" --approve-level high  # Prompts for critical tools only
+praisonai "task" --approve-level medium         # Prompts for high and critical
+
+# Default behavior (no flags): prompts for all dangerous tools
+praisonai "run shell command"  # Will prompt for approval
+```
+
 ### Memory CLI:
 ```bash
 # Enable memory for agent (persists across sessions)
@@ -1188,6 +1244,36 @@ praisonai "Analyze this data" --metrics
 praisonai "Complex task" --metrics --planning
 ```
 
+### Scheduler CLI:
+```bash
+# Schedule an agent using agents.yaml
+praisonai schedule agents.yaml
+
+# Override interval from CLI
+praisonai schedule agents.yaml --interval "*/30m"
+
+# With verbose logging
+praisonai schedule agents.yaml --verbose
+```
+
+**agents.yaml with schedule:**
+```yaml
+framework: praisonai
+
+agents:
+  - name: "AI News Monitor"
+    instructions: "Search and summarize AI news"
+    tools:
+      - search_tool
+
+task: "Search for latest AI news"
+
+schedule:
+  interval: "hourly"  # hourly, daily, */30m, */6h
+  max_retries: 3
+  run_immediately: true
+```
+
 ### Image Processing CLI:
 ```bash
 # Process images with vision-based tasks
@@ -1374,8 +1460,13 @@ praisonai "Complex analysis" --router --router-provider anthropic
 # Router automatically selects:
 # - Simple tasks → gpt-4o-mini, claude-3-haiku
 # - Complex tasks → gpt-4-turbo, claude-3-opus
+
+# Create workflow with model routing template
+praisonai workflow create --template model-routing --output my_workflow.yaml
 ```
 
+Custom models can be configured in `agents.yaml`. See [Model Router Docs](https://docs.praison.ai/features/model-router) for details.
+
 ### Flow Display CLI:
 ```bash
 # Enable visual workflow tracking
@@ -1427,13 +1518,31 @@ praisonai mcp help
 
 ### AI Commit CLI:
 ```bash
-# Generate AI commit message for staged changes
+# Full auto mode: stage all, security check, commit, and push
+praisonai commit -a
+
+# Interactive mode (requires git add first)
 praisonai commit
 
-# Generate, commit, and push
+# Interactive with auto-push
 praisonai commit --push
+
+# Skip security check (not recommended)
+praisonai commit -a --no-verify
 ```
 
+**Features:**
+- 🤖 AI-generated conventional commit messages
+- 🔒 Built-in security scanning (API keys, passwords, secrets, sensitive files)
+- 📦 Auto-staging with `-a` flag
+- 🚀 Auto-push in full auto mode
+- ✏️ Edit message before commit in interactive mode
+
+**Security Detection:**
+- API keys, secrets, tokens (AWS, GitHub, GitLab, Slack)
+- Passwords and private keys
+- Sensitive files (`.env`, `id_rsa`, `.pem`, `.key`, etc.)
+
 ### Serve CLI (API Server):
 ```bash
 # Start API server for agents defined in YAML
@@ -1464,6 +1573,55 @@ export N8N_API_KEY="your-api-key"
 praisonai agents.yaml --n8n
 ```
 
+### External Agents CLI:
+
+Use external AI coding CLI tools (Claude Code, Gemini CLI, Codex CLI, Cursor CLI) as agent tools:
+
+```bash
+# Use Claude Code for coding tasks
+praisonai "Refactor the auth module" --external-agent claude
+
+# Use Gemini CLI for code analysis
+praisonai "Analyze codebase architecture" --external-agent gemini
+
+# Use OpenAI Codex CLI
+praisonai "Fix all bugs in src/" --external-agent codex
+
+# Use Cursor CLI
+praisonai "Add comprehensive tests" --external-agent cursor
+```
+
+**Python API:**
+```python
+from praisonai.integrations import (
+    ClaudeCodeIntegration,
+    GeminiCLIIntegration,
+    CodexCLIIntegration,
+    CursorCLIIntegration
+)
+
+# Create integration
+claude = ClaudeCodeIntegration(workspace="/project")
+
+# Execute a coding task
+result = await claude.execute("Refactor the auth module")
+
+# Use as agent tool
+from praisonai import Agent
+tool = claude.as_tool()
+agent = Agent(tools=[tool])
+```
+
+**Environment Variables:**
+```bash
+export ANTHROPIC_API_KEY=your-key  # Claude Code
+export GEMINI_API_KEY=your-key     # Gemini CLI
+export OPENAI_API_KEY=your-key     # Codex CLI
+export CURSOR_API_KEY=your-key     # Cursor CLI
+```
+
+See [External Agents Documentation](https://docs.praison.ai/code/external-agents) for more details.
+
 ### @Mentions in Prompts:
 ```bash
 # Include file content in prompt
@@ -1689,32 +1847,32 @@ app.include_router(a2a.get_router())
 
 | Feature | Docs |
 |---------|:----:|
-| 🔄 Query Rewrite - RAG optimization | [📖](https://docs.praison.ai/cli/query-rewrite) |
-| 🔬 Deep Research - Automated research | [📖](https://docs.praison.ai/cli/deep-research) |
-| 📋 Planning - Step-by-step execution | [📖](https://docs.praison.ai/cli/planning) |
-| 💾 Memory - Persistent agent memory | [📖](https://docs.praison.ai/cli/memory) |
-| 📜 Rules - Auto-discovered instructions | [📖](https://docs.praison.ai/cli/rules) |
-| 🔄 Workflow - Multi-step workflows | [📖](https://docs.praison.ai/cli/workflow) |
-| 🪝 Hooks - Event-driven actions | [📖](https://docs.praison.ai/cli/hooks) |
-| 🧠 Claude Memory - Anthropic memory tool | [📖](https://docs.praison.ai/cli/claude-memory) |
-| 🛡️ Guardrail - Output validation | [📖](https://docs.praison.ai/cli/guardrail) |
-| 📊 Metrics - Token usage tracking | [📖](https://docs.praison.ai/cli/metrics) |
-| 🖼️ Image - Vision processing | [📖](https://docs.praison.ai/cli/image) |
-| 📡 Telemetry - Usage monitoring | [📖](https://docs.praison.ai/cli/telemetry) |
-| 🔌 MCP - Model Context Protocol | [📖](https://docs.praison.ai/cli/mcp) |
-| ⚡ Fast Context - Codebase search | [📖](https://docs.praison.ai/cli/fast-context) |
-| 📚 Knowledge - RAG management | [📖](https://docs.praison.ai/cli/knowledge) |
-| 💬 Session - Conversation management | [📖](https://docs.praison.ai/cli/session) |
-| 🔧 Tools - Tool discovery | [📖](https://docs.praison.ai/cli/tools) |
-| 🤝 Handoff - Agent delegation | [📖](https://docs.praison.ai/cli/handoff) |
-| 🧠 Auto Memory - Memory extraction | [📖](https://docs.praison.ai/cli/auto-memory) |
-| 📋 Todo - Task management | [📖](https://docs.praison.ai/cli/todo) |
-| 🎯 Router - Smart model selection | [📖](https://docs.praison.ai/cli/router) |
-| 📈 Flow Display - Visual workflow | [📖](https://docs.praison.ai/cli/flow-display) |
-| ✨ Prompt Expansion - Detailed prompts | [📖](https://docs.praison.ai/cli/prompt-expansion) |
-| 🌐 Web Search - Real-time search | [📖](https://docs.praison.ai/cli/web-search) |
-| 📥 Web Fetch - URL content retrieval | [📖](https://docs.praison.ai/cli/web-fetch) |
-| 💾 Prompt Caching - Cost reduction | [📖](https://docs.praison.ai/cli/prompt-caching) |
+| 🔄 Query Rewrite - RAG optimization | [📖](https://docs.praison.ai/docs/cli/query-rewrite) |
+| 🔬 Deep Research - Automated research | [📖](https://docs.praison.ai/docs/cli/deep-research) |
+| 📋 Planning - Step-by-step execution | [📖](https://docs.praison.ai/docs/cli/planning) |
+| 💾 Memory - Persistent agent memory | [📖](https://docs.praison.ai/docs/cli/memory) |
+| 📜 Rules - Auto-discovered instructions | [📖](https://docs.praison.ai/docs/cli/rules) |
+| 🔄 Workflow - Multi-step workflows | [📖](https://docs.praison.ai/docs/cli/workflow) |
+| 🪝 Hooks - Event-driven actions | [📖](https://docs.praison.ai/docs/cli/hooks) |
+| 🧠 Claude Memory - Anthropic memory tool | [📖](https://docs.praison.ai/docs/cli/claude-memory) |
+| 🛡️ Guardrail - Output validation | [📖](https://docs.praison.ai/docs/cli/guardrail) |
+| 📊 Metrics - Token usage tracking | [📖](https://docs.praison.ai/docs/cli/metrics) |
+| 🖼️ Image - Vision processing | [📖](https://docs.praison.ai/docs/cli/image) |
+| 📡 Telemetry - Usage monitoring | [📖](https://docs.praison.ai/docs/cli/telemetry) |
+| 🔌 MCP - Model Context Protocol | [📖](https://docs.praison.ai/docs/cli/mcp) |
+| ⚡ Fast Context - Codebase search | [📖](https://docs.praison.ai/docs/cli/fast-context) |
+| 📚 Knowledge - RAG management | [📖](https://docs.praison.ai/docs/cli/knowledge) |
+| 💬 Session - Conversation management | [📖](https://docs.praison.ai/docs/cli/session) |
+| 🔧 Tools - Tool discovery | [📖](https://docs.praison.ai/docs/cli/tools) |
+| 🤝 Handoff - Agent delegation | [📖](https://docs.praison.ai/docs/cli/handoff) |
+| 🧠 Auto Memory - Memory extraction | [📖](https://docs.praison.ai/docs/cli/auto-memory) |
+| 📋 Todo - Task management | [📖](https://docs.praison.ai/docs/cli/todo) |
+| 🎯 Router - Smart model selection | [📖](https://docs.praison.ai/docs/cli/router) |
+| 📈 Flow Display - Visual workflow | [📖](https://docs.praison.ai/docs/cli/flow-display) |
+| ✨ Prompt Expansion - Detailed prompts | [📖](https://docs.praison.ai/docs/cli/prompt-expansion) |
+| 🌐 Web Search - Real-time search | [📖](https://docs.praison.ai/docs/cli/web-search) |
+| 📥 Web Fetch - URL content retrieval | [📖](https://docs.praison.ai/docs/cli/web-fetch) |
+| 💾 Prompt Caching - Cost reduction | [📖](https://docs.praison.ai/docs/cli/prompt-caching) |
 
 ---
 
@@ -2266,7 +2424,7 @@ PraisonAI provides zero-dependency persistent memory for agents. For detailed ex
 - 📖 **Wikipedia Agent** - Search and extract Wikipedia information
 - 💻 **Programming Agent** - Code development and analysis
 - 📝 **Markdown Agent** - Generate and format Markdown content
-- 🔀 **Router Agent** - Dynamic task routing with cost optimisation
+- 🔀 **Model Router** - Smart model selection based on task complexity
 
 ### MCP Protocol
 
@@ -2287,6 +2445,7 @@ PraisonAI provides zero-dependency persistent memory for agents. For detailed ex
 - 🤝 **Agent Handoffs** - Transfer context between specialised agents
 - 🛡️ **Guardrails** - Input/output validation and safety checks
 - ✅ **Human Approval** - Require human confirmation for critical actions
+- 🔐 **Tool Approval CLI** - `--trust` (auto-approve all) and `--approve-level` (risk-based approval)
 - 💬 **Sessions Management** - Isolated conversation contexts
 - 🔄 **Stateful Agents** - Maintain state across interactions
 

src/praisonai/benchmarks/BENCHMARK_RESULTS.md

@@ -0,0 +1,33 @@
+# PraisonAI CLI - Benchmark Results
+
+**Generated:** 2025-12-19 16:04:40
+
+## Import Times
+
+| Module | Time (ms) | Target | Status |
+|--------|-----------|--------|--------|
+| praisonai | 4.11 | <10 | ✅ |
+| message_queue | 6.87 | <50 | ✅ |
+| at_mentions | 0.58 | <50 | ✅ |
+| profiler | 0.90 | <10 | ✅ |
+
+## Instantiation Times
+
+| Class | Time (μs) | Target | Status |
+|-------|-----------|--------|--------|
+| MessageQueue | 0.26 | <100 | ✅ |
+| StateManager | 0.30 | <100 | ✅ |
+| FileSearchService | 8.42 | <100 | ✅ |
+
+## Lazy Loading
+
+| Operation | Time (ms) |
+|-----------|----------|
+| PraisonAI lazy load | 3886.47 |
+
+## How to Reproduce
+
+```bash
+cd praisonai
+python benchmarks/simple_benchmark.py
+```

src/praisonai/benchmarks/simple_benchmark.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""
+PraisonAI CLI - Performance Benchmark
+
+Measures import times and module loading performance.
+
+Usage:
+    python benchmarks/simple_benchmark.py
+    python benchmarks/simple_benchmark.py --no-save
+"""
+
+import time
+import sys
+import os
+import argparse
+from datetime import datetime
+
+
+ITERATIONS = 100
+
+
+def measure_import(module_name: str) -> float:
+    """Measure import time in milliseconds."""
+    # Clear from cache if present
+    modules_to_remove = [k for k in sys.modules.keys() if k.startswith(module_name)]
+    for mod in modules_to_remove:
+        del sys.modules[mod]
+    
+    start = time.perf_counter()
+    __import__(module_name)
+    return (time.perf_counter() - start) * 1000
+
+
+def measure_instantiation(create_fn, iterations=ITERATIONS) -> float:
+    """Measure average instantiation time in microseconds."""
+    times = []
+    for _ in range(iterations):
+        start = time.perf_counter()
+        create_fn()
+        times.append((time.perf_counter() - start) * 1_000_000)
+    return sum(times) / len(times)
+
+
+def run_benchmark():
+    """Run the benchmark."""
+    results = {}
+    
+    print('=' * 60)
+    print('PraisonAI CLI - Performance Benchmark')
+    print('=' * 60)
+    print(f'\nIterations: {ITERATIONS}')
+    print('Metrics: Import time (ms), Instantiation time (μs)\n')
+    
+    # 1. Package import time
+    print("1. Testing package imports...")
+    
+    # Clear cache
+    modules_to_remove = [k for k in sys.modules.keys() if 'praisonai' in k]
+    for mod in modules_to_remove:
+        del sys.modules[mod]
+    
+    start = time.perf_counter()
+    import praisonai
+    results['praisonai_import_ms'] = (time.perf_counter() - start) * 1000
+    print(f"   import praisonai: {results['praisonai_import_ms']:.2f}ms")
+    
+    # 2. CLI features import
+    print("\n2. Testing CLI features imports...")
+    
+    start = time.perf_counter()
+    from praisonai.cli.features.message_queue import MessageQueue
+    results['message_queue_import_ms'] = (time.perf_counter() - start) * 1000
+    print(f"   message_queue: {results['message_queue_import_ms']:.2f}ms")
+    
+    start = time.perf_counter()
+    from praisonai.cli.features.at_mentions import CombinedCompleter
+    results['at_mentions_import_ms'] = (time.perf_counter() - start) * 1000
+    print(f"   at_mentions: {results['at_mentions_import_ms']:.2f}ms")
+    
+    # 3. Profiler import (should be fast, standalone)
+    print("\n3. Testing profiler import...")
+    start = time.perf_counter()
+    from praisonai.profiler import Profiler
+    results['profiler_import_ms'] = (time.perf_counter() - start) * 1000
+    print(f"   profiler: {results['profiler_import_ms']:.2f}ms")
+    
+    # 4. Instantiation benchmarks
+    print(f"\n4. Testing instantiation ({ITERATIONS} iterations)...")
+    
+    from praisonai.cli.features.message_queue import MessageQueue, StateManager
+    from praisonai.cli.features.at_mentions import FileSearchService
+    
+    results['MessageQueue_us'] = measure_instantiation(lambda: MessageQueue())
+    print(f"   MessageQueue: {results['MessageQueue_us']:.2f}μs")
+    
+    results['StateManager_us'] = measure_instantiation(lambda: StateManager())
+    print(f"   StateManager: {results['StateManager_us']:.2f}μs")
+    
+    results['FileSearchService_us'] = measure_instantiation(
+        lambda: FileSearchService(root_dir=".")
+    )
+    print(f"   FileSearchService: {results['FileSearchService_us']:.2f}μs")
+    
+    # 5. PraisonAI class (lazy load)
+    print("\n5. Testing PraisonAI class access (lazy load)...")
+    start = time.perf_counter()
+    PraisonAI = praisonai.PraisonAI
+    results['PraisonAI_lazy_ms'] = (time.perf_counter() - start) * 1000
+    print(f"   PraisonAI lazy load: {results['PraisonAI_lazy_ms']:.2f}ms")
+    
+    return results
+
+
+def print_summary(results: dict):
+    """Print benchmark summary."""
+    print('\n' + '=' * 60)
+    print('SUMMARY')
+    print('=' * 60)
+    
+    print('\nImport Times (target: <50ms for features, <10ms for package):')
+    print(f"  {'Module':<25} {'Time':>10} {'Status':>10}")
+    print(f"  {'-'*25} {'-'*10} {'-'*10}")
+    
+    import_checks = [
+        ('praisonai', results['praisonai_import_ms'], 10),
+        ('message_queue', results['message_queue_import_ms'], 50),
+        ('at_mentions', results['at_mentions_import_ms'], 50),
+        ('profiler', results['profiler_import_ms'], 10),
+    ]
+    
+    all_pass = True
+    for name, time_ms, threshold in import_checks:
+        status = '✅ PASS' if time_ms < threshold else '❌ SLOW'
+        if time_ms >= threshold:
+            all_pass = False
+        print(f"  {name:<25} {time_ms:>8.2f}ms {status:>10}")
+    
+    print('\nInstantiation Times (target: <100μs):')
+    print(f"  {'Class':<25} {'Time':>10} {'Status':>10}")
+    print(f"  {'-'*25} {'-'*10} {'-'*10}")
+    
+    inst_checks = [
+        ('MessageQueue', results['MessageQueue_us'], 100),
+        ('StateManager', results['StateManager_us'], 100),
+        ('FileSearchService', results['FileSearchService_us'], 100),
+    ]
+    
+    for name, time_us, threshold in inst_checks:
+        status = '✅ PASS' if time_us < threshold else '❌ SLOW'
+        if time_us >= threshold:
+            all_pass = False
+        print(f"  {name:<25} {time_us:>8.2f}μs {status:>10}")
+    
+    print('\n' + '=' * 60)
+    if all_pass:
+        print('✅ All benchmarks PASSED')
+    else:
+        print('❌ Some benchmarks FAILED')
+    print('=' * 60)
+    
+    return all_pass
+
+
+def save_results(results: dict):
+    """Save benchmark results to markdown file."""
+    filepath = os.path.join(os.path.dirname(__file__), 'BENCHMARK_RESULTS.md')
+    
+    with open(filepath, 'w') as f:
+        f.write('# PraisonAI CLI - Benchmark Results\n\n')
+        f.write(f'**Generated:** {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}\n\n')
+        
+        f.write('## Import Times\n\n')
+        f.write('| Module | Time (ms) | Target | Status |\n')
+        f.write('|--------|-----------|--------|--------|\n')
+        
+        import_data = [
+            ('praisonai', results['praisonai_import_ms'], 10),
+            ('message_queue', results['message_queue_import_ms'], 50),
+            ('at_mentions', results['at_mentions_import_ms'], 50),
+            ('profiler', results['profiler_import_ms'], 10),
+        ]
+        
+        for name, time_ms, threshold in import_data:
+            status = '✅' if time_ms < threshold else '❌'
+            f.write(f'| {name} | {time_ms:.2f} | <{threshold} | {status} |\n')
+        
+        f.write('\n## Instantiation Times\n\n')
+        f.write('| Class | Time (μs) | Target | Status |\n')
+        f.write('|-------|-----------|--------|--------|\n')
+        
+        inst_data = [
+            ('MessageQueue', results['MessageQueue_us'], 100),
+            ('StateManager', results['StateManager_us'], 100),
+            ('FileSearchService', results['FileSearchService_us'], 100),
+        ]
+        
+        for name, time_us, threshold in inst_data:
+            status = '✅' if time_us < threshold else '❌'
+            f.write(f'| {name} | {time_us:.2f} | <{threshold} | {status} |\n')
+        
+        f.write('\n## Lazy Loading\n\n')
+        f.write(f'| Operation | Time (ms) |\n')
+        f.write(f'|-----------|----------|\n')
+        f.write(f'| PraisonAI lazy load | {results["PraisonAI_lazy_ms"]:.2f} |\n')
+        
+        f.write('\n## How to Reproduce\n\n')
+        f.write('```bash\n')
+        f.write('cd praisonai\n')
+        f.write('python benchmarks/simple_benchmark.py\n')
+        f.write('```\n')
+    
+    print(f'\nResults saved to: {filepath}')
+    return filepath
+
+
+def main():
+    parser = argparse.ArgumentParser(description='PraisonAI CLI Performance Benchmark')
+    parser.add_argument('--no-save', action='store_true', help='Do not save results to file')
+    args = parser.parse_args()
+    
+    results = run_benchmark()
+    all_pass = print_summary(results)
+    
+    if not args.no_save:
+        save_results(results)
+    
+    return 0 if all_pass else 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

src/praisonai/praisonai.rb

@@ -3,8 +3,8 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.44.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.44.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.65.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.65.tar.gz | shasum -a 256`.split.first
     license "MIT"
   
     depends_on "[email protected]"

src/praisonai/praisonai/__init__.py

@@ -1,31 +1,34 @@
+# Suppress crewai.cli.config logger BEFORE any imports to prevent INFO log
+import logging
+logging.getLogger('crewai.cli.config').setLevel(logging.ERROR)
+
 # Disable OpenTelemetry SDK
 import os
 os.environ["OTEL_SDK_DISABLED"] = "true"
 os.environ["EC_TELEMETRY"] = "false"
-from .cli import PraisonAI
+
+# Version is lightweight, import directly
 from .version import __version__
 
-# Re-export all classes from praisonaiagents to enable:
-# from praisonai import Agent, Task, PraisonAIAgents
-try:
-    import praisonaiagents
-    # Import all symbols from praisonaiagents using * import
-    from praisonaiagents import *
-except ImportError:
-    # If praisonaiagents is not available, these imports will fail gracefully
-    pass
-
-# Define __all__ to include both PraisonAI core classes and praisonaiagents exports
+# Define __all__ for lazy loading
 __all__ = [
-    # Core PraisonAI classes
     'PraisonAI',
     '__version__',
 ]
 
-# Dynamically extend __all__ with praisonaiagents exports
-try:
-    import praisonaiagents
-    __all__.extend(praisonaiagents.__all__)
-except (ImportError, AttributeError):
-    # If praisonaiagents is not available or doesn't have __all__, fail gracefully
-    pass
+# Lazy loading for heavy imports
+def __getattr__(name):
+    """Lazy load heavy modules to improve import time."""
+    if name == 'PraisonAI':
+        from .cli import PraisonAI
+        return PraisonAI
+    
+    # Try praisonaiagents exports
+    try:
+        import praisonaiagents
+        if hasattr(praisonaiagents, name):
+            return getattr(praisonaiagents, name)
+    except ImportError:
+        pass
+    
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

src/praisonai/praisonai/agent_scheduler.py

@@ -0,0 +1,337 @@
+"""
+Agent Scheduler for PraisonAI - Run agents periodically 24/7.
+
+This module provides scheduling capabilities for running PraisonAI agents
+at regular intervals, enabling 24/7 autonomous agent operations.
+
+Example:
+    # Run news checker every hour
+    from praisonai.agent_scheduler import AgentScheduler
+    from praisonai_agents import Agent
+    
+    agent = Agent(
+        name="NewsChecker",
+        instructions="Check latest AI news and summarize",
+        tools=[search_tool]
+    )
+    
+    scheduler = AgentScheduler(agent, task="Check latest AI news")
+    scheduler.start(schedule_expr="hourly")
+"""
+
+import threading
+import time
+import logging
+from datetime import datetime
+from typing import Optional, Dict, Any, Callable
+from abc import ABC, abstractmethod
+
+logger = logging.getLogger(__name__)
+
+
+class ScheduleParser:
+    """Parse schedule expressions into intervals."""
+    
+    @staticmethod
+    def parse(schedule_expr: str) -> int:
+        """
+        Parse schedule expression and return interval in seconds.
+        
+        Supported formats:
+        - "daily" -> 86400 seconds
+        - "hourly" -> 3600 seconds
+        - "*/30m" -> 1800 seconds (every 30 minutes)
+        - "*/1h" -> 3600 seconds (every 1 hour)
+        - "60" -> 60 seconds (plain number)
+        
+        Args:
+            schedule_expr: Schedule expression string
+            
+        Returns:
+            Interval in seconds
+            
+        Raises:
+            ValueError: If schedule format is not supported
+        """
+        schedule_expr = schedule_expr.strip().lower()
+        
+        if schedule_expr == "daily":
+            return 86400
+        elif schedule_expr == "hourly":
+            return 3600
+        elif schedule_expr.isdigit():
+            return int(schedule_expr)
+        elif schedule_expr.startswith("*/"):
+            interval_part = schedule_expr[2:]
+            if interval_part.endswith("m"):
+                minutes = int(interval_part[:-1])
+                return minutes * 60
+            elif interval_part.endswith("h"):
+                hours = int(interval_part[:-1])
+                return hours * 3600
+            elif interval_part.endswith("s"):
+                return int(interval_part[:-1])
+            else:
+                return int(interval_part)
+        else:
+            raise ValueError(f"Unsupported schedule format: {schedule_expr}")
+
+
+class AgentExecutorInterface(ABC):
+    """Abstract interface for agent execution."""
+    
+    @abstractmethod
+    def execute(self, task: str) -> Any:
+        """Execute the agent with given task."""
+        pass
+
+
+class PraisonAgentExecutor(AgentExecutorInterface):
+    """Executor for PraisonAI agents."""
+    
+    def __init__(self, agent):
+        """
+        Initialize executor with a PraisonAI agent.
+        
+        Args:
+            agent: PraisonAI Agent instance
+        """
+        self.agent = agent
+        
+    def execute(self, task: str) -> Any:
+        """
+        Execute the agent with given task.
+        
+        Args:
+            task: Task description for the agent
+            
+        Returns:
+            Agent execution result
+        """
+        try:
+            result = self.agent.start(task)
+            return result
+        except Exception as e:
+            logger.error(f"Agent execution failed: {e}")
+            raise
+
+
+class AgentScheduler:
+    """
+    Scheduler for running PraisonAI agents periodically.
+    
+    Features:
+    - Interval-based scheduling (hourly, daily, custom)
+    - Thread-safe operation
+    - Automatic retry on failure
+    - Execution logging and monitoring
+    - Graceful shutdown
+    
+    Example:
+        scheduler = AgentScheduler(agent, task="Check news")
+        scheduler.start(schedule_expr="hourly", max_retries=3)
+        # Agent runs every hour automatically
+        scheduler.stop()  # Stop when needed
+    """
+    
+    def __init__(
+        self,
+        agent,
+        task: str,
+        config: Optional[Dict[str, Any]] = None,
+        on_success: Optional[Callable] = None,
+        on_failure: Optional[Callable] = None
+    ):
+        """
+        Initialize agent scheduler.
+        
+        Args:
+            agent: PraisonAI Agent instance
+            task: Task description to execute
+            config: Optional configuration dict
+            on_success: Callback function on successful execution
+            on_failure: Callback function on failed execution
+        """
+        self.agent = agent
+        self.task = task
+        self.config = config or {}
+        self.on_success = on_success
+        self.on_failure = on_failure
+        
+        self.is_running = False
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._executor = PraisonAgentExecutor(agent)
+        self._execution_count = 0
+        self._success_count = 0
+        self._failure_count = 0
+        
+    def start(
+        self,
+        schedule_expr: str,
+        max_retries: int = 3,
+        run_immediately: bool = False
+    ) -> bool:
+        """
+        Start scheduled agent execution.
+        
+        Args:
+            schedule_expr: Schedule expression (e.g., "hourly", "*/1h", "3600")
+            max_retries: Maximum retry attempts on failure
+            run_immediately: If True, run agent immediately before starting schedule
+            
+        Returns:
+            True if scheduler started successfully
+        """
+        if self.is_running:
+            logger.warning("Scheduler is already running")
+            return False
+            
+        try:
+            interval = ScheduleParser.parse(schedule_expr)
+            self.is_running = True
+            self._stop_event.clear()
+            
+            logger.info(f"Starting agent scheduler: {self.agent.name if hasattr(self.agent, 'name') else 'Agent'}")
+            logger.info(f"Task: {self.task}")
+            logger.info(f"Schedule: {schedule_expr} ({interval}s interval)")
+            logger.info(f"Max retries: {max_retries}")
+            
+            # Run immediately if requested
+            if run_immediately:
+                logger.info("Running agent immediately before starting schedule...")
+                self._execute_with_retry(max_retries)
+            
+            self._thread = threading.Thread(
+                target=self._run_schedule,
+                args=(interval, max_retries),
+                daemon=True
+            )
+            self._thread.start()
+            
+            logger.info("Agent scheduler started successfully")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to start scheduler: {e}")
+            self.is_running = False
+            return False
+    
+    def stop(self) -> bool:
+        """
+        Stop the scheduler gracefully.
+        
+        Returns:
+            True if stopped successfully
+        """
+        if not self.is_running:
+            logger.info("Scheduler is not running")
+            return True
+            
+        logger.info("Stopping agent scheduler...")
+        self._stop_event.set()
+        
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=10)
+            
+        self.is_running = False
+        logger.info("Agent scheduler stopped")
+        logger.info(f"Execution stats - Total: {self._execution_count}, Success: {self._success_count}, Failed: {self._failure_count}")
+        return True
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """
+        Get execution statistics.
+        
+        Returns:
+            Dictionary with execution stats
+        """
+        return {
+            "is_running": self.is_running,
+            "total_executions": self._execution_count,
+            "successful_executions": self._success_count,
+            "failed_executions": self._failure_count,
+            "success_rate": (self._success_count / self._execution_count * 100) if self._execution_count > 0 else 0
+        }
+    
+    def _run_schedule(self, interval: int, max_retries: int):
+        """Internal method to run scheduled agent executions."""
+        while not self._stop_event.is_set():
+            logger.info(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Starting scheduled agent execution")
+            
+            self._execute_with_retry(max_retries)
+            
+            # Wait for next scheduled time
+            logger.info(f"Next execution in {interval} seconds ({interval/3600:.1f} hours)")
+            self._stop_event.wait(interval)
+    
+    def _execute_with_retry(self, max_retries: int):
+        """Execute agent with retry logic."""
+        self._execution_count += 1
+        success = False
+        
+        for attempt in range(max_retries):
+            try:
+                logger.info(f"Attempt {attempt + 1}/{max_retries}")
+                result = self._executor.execute(self.task)
+                
+                logger.info(f"Agent execution successful on attempt {attempt + 1}")
+                logger.info(f"Result: {result}")
+                
+                self._success_count += 1
+                success = True
+                
+                if self.on_success:
+                    self.on_success(result)
+                    
+                break
+                
+            except Exception as e:
+                logger.error(f"Agent execution failed on attempt {attempt + 1}: {e}")
+                
+                if attempt < max_retries - 1:
+                    wait_time = 30 * (attempt + 1)  # Exponential backoff
+                    logger.info(f"Waiting {wait_time}s before retry...")
+                    time.sleep(wait_time)
+        
+        if not success:
+            self._failure_count += 1
+            logger.error(f"Agent execution failed after {max_retries} attempts")
+            
+            if self.on_failure:
+                self.on_failure(f"Failed after {max_retries} attempts")
+    
+    def execute_once(self) -> Any:
+        """
+        Execute agent immediately (one-time execution).
+        
+        Returns:
+            Agent execution result
+        """
+        logger.info("Executing agent once")
+        try:
+            result = self._executor.execute(self.task)
+            logger.info(f"One-time execution successful: {result}")
+            return result
+        except Exception as e:
+            logger.error(f"One-time execution failed: {e}")
+            raise
+
+
+def create_agent_scheduler(
+    agent,
+    task: str,
+    config: Optional[Dict[str, Any]] = None
+) -> AgentScheduler:
+    """
+    Factory function to create agent scheduler.
+    
+    Args:
+        agent: PraisonAI Agent instance
+        task: Task description
+        config: Optional configuration
+        
+    Returns:
+        Configured AgentScheduler instance
+    """
+    return AgentScheduler(agent, task, config)

src/praisonai/praisonai/cli/__init__.py

@@ -8,12 +8,19 @@ Structure:
 - features/: Feature handlers for CLI flags and commands
 """
 
-from .main import PraisonAI
-
 __all__ = ["PraisonAI"]
 
 
+def __getattr__(name):
+    """Lazy load PraisonAI to avoid slow imports."""
+    if name == "PraisonAI":
+        from .main import PraisonAI
+        return PraisonAI
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
 def main():
     """CLI entry point function."""
+    from .main import PraisonAI
     praison_ai = PraisonAI()
     praison_ai.main()

src/praisonai/praisonai/cli/features/__init__.py

@@ -22,6 +22,11 @@ Features:
 - workflow: YAML workflow management
 - n8n: Export workflows to n8n visual editor
 - external_agents: External AI CLI tool integrations (Claude, Gemini, Codex, Cursor)
+- slash_commands: Interactive slash commands (/help, /cost, /plan, etc.)
+- autonomy_mode: Autonomy levels (suggest, auto-edit, full-auto)
+- cost_tracker: Real-time cost and token tracking
+- message_queue: Message queuing while agent is processing
+- at_mentions: @ mention autocomplete for files and directories
 """
 
 # Type hints available for IDE support
@@ -45,6 +50,19 @@ __all__ = [
     'WorkflowHandler',
     'N8nHandler',
     'ExternalAgentsHandler',
+    # New CLI enhancement features
+    'SlashCommandHandler',
+    'AutonomyModeHandler',
+    'CostTrackerHandler',
+    'RepoMapHandler',
+    'InteractiveTUIHandler',
+    'GitIntegrationHandler',
+    'SandboxExecutorHandler',
+    'MessageQueueHandler',
+    # @ mention autocomplete
+    'AtMentionCompleter',
+    'CombinedCompleter',
+    'FileSearchService',
 ]
 
 def __getattr__(name):
@@ -100,4 +118,39 @@ def __getattr__(name):
     elif name == 'ExternalAgentsHandler':
         from .external_agents import ExternalAgentsHandler
         return ExternalAgentsHandler
+    # New CLI enhancement features
+    elif name == 'SlashCommandHandler':
+        from .slash_commands import SlashCommandHandler
+        return SlashCommandHandler
+    elif name == 'AutonomyModeHandler':
+        from .autonomy_mode import AutonomyModeHandler
+        return AutonomyModeHandler
+    elif name == 'CostTrackerHandler':
+        from .cost_tracker import CostTrackerHandler
+        return CostTrackerHandler
+    elif name == 'RepoMapHandler':
+        from .repo_map import RepoMapHandler
+        return RepoMapHandler
+    elif name == 'InteractiveTUIHandler':
+        from .interactive_tui import InteractiveTUIHandler
+        return InteractiveTUIHandler
+    elif name == 'GitIntegrationHandler':
+        from .git_integration import GitIntegrationHandler
+        return GitIntegrationHandler
+    elif name == 'SandboxExecutorHandler':
+        from .sandbox_executor import SandboxExecutorHandler
+        return SandboxExecutorHandler
+    elif name == 'MessageQueueHandler':
+        from .message_queue import MessageQueueHandler
+        return MessageQueueHandler
+    # @ mention autocomplete
+    elif name == 'AtMentionCompleter':
+        from .at_mentions import AtMentionCompleter
+        return AtMentionCompleter
+    elif name == 'CombinedCompleter':
+        from .at_mentions import CombinedCompleter
+        return CombinedCompleter
+    elif name == 'FileSearchService':
+        from .at_mentions import FileSearchService
+        return FileSearchService
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

src/praisonai/praisonai/cli/features/agent_scheduler.py

@@ -0,0 +1,182 @@
+"""
+Agent Scheduler CLI Feature.
+
+Provides CLI commands for scheduling agents to run 24/7 at regular intervals.
+"""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AgentSchedulerHandler:
+    """Handler for agent scheduler CLI commands."""
+    
+    @staticmethod
+    def handle_schedule_command(args) -> int:
+        """
+        Handle the schedule command for running agents periodically.
+        
+        Args:
+            args: Parsed command-line arguments
+            
+        Returns:
+            Exit code (0 for success, 1 for error)
+        """
+        try:
+            from praisonai.scheduler import AgentScheduler
+        except ImportError:
+            print("Error: praisonai.scheduler module not found")
+            print("Please ensure PraisonAI is properly installed")
+            return 1
+        
+        # Get YAML file path (default to agents.yaml)
+        yaml_path = getattr(args, 'schedule_yaml', None) or 'agents.yaml'
+        
+        # Get overrides from CLI
+        interval_override = getattr(args, 'schedule_interval', None)
+        max_retries_override = getattr(args, 'schedule_max_retries', None)
+        verbose = getattr(args, 'verbose', False)
+        
+        # Set up logging
+        if verbose:
+            logging.basicConfig(
+                level=logging.INFO,
+                format='[%(asctime)s] %(levelname)s - %(message)s',
+                datefmt='%Y-%m-%d %H:%M:%S'
+            )
+        
+        try:
+            # Create scheduler from YAML
+            print(f"🤖 Loading agent configuration from: {yaml_path}")
+            scheduler = AgentScheduler.from_yaml(
+                yaml_path=yaml_path,
+                interval_override=interval_override,
+                max_retries_override=max_retries_override
+            )
+            
+            # Display configuration
+            agent_name = getattr(scheduler.agent, 'name', 'Agent')
+            print(f"\n{'='*60}")
+            print(f"🤖 Starting 24/7 {agent_name}")
+            print(f"{'='*60}")
+            print(f"Task: {scheduler.task[:80]}{'...' if len(scheduler.task) > 80 else ''}")
+            
+            # Get schedule info
+            schedule_config = scheduler._yaml_schedule_config
+            interval = interval_override or schedule_config.get('interval', 'hourly')
+            max_retries = max_retries_override or schedule_config.get('max_retries', 3)
+            
+            print(f"Schedule: {interval}")
+            print(f"Max Retries: {max_retries}")
+            print(f"{'='*60}\n")
+            
+            # Start scheduler
+            print("⏰ Starting scheduler... (Press Ctrl+C to stop)\n")
+            scheduler.start_from_yaml_config()
+            
+            # Keep running until interrupted
+            try:
+                while scheduler.is_running:
+                    import time
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                print("\n\n🛑 Stopping scheduler...")
+                scheduler.stop()
+                
+                # Display final stats
+                stats = scheduler.get_stats()
+                print("\n📊 Final Statistics:")
+                print(f"  Total Executions: {stats['total_executions']}")
+                print(f"  Successful: {stats['successful_executions']}")
+                print(f"  Failed: {stats['failed_executions']}")
+                print(f"  Success Rate: {stats['success_rate']:.1f}%")
+                print("\n✅ Agent stopped successfully\n")
+                
+            return 0
+            
+        except FileNotFoundError as e:
+            print(f"❌ Error: {e}")
+            print(f"\nMake sure {yaml_path} exists in the current directory.")
+            print("\nExample agents.yaml structure:")
+            print("""
+framework: praisonai
+
+agents:
+  - name: "AI News Monitor"
+    role: "News Analyst"
+    instructions: "Search and summarize AI news"
+    tools:
+      - search_tool
+
+task: "Search for latest AI news"
+
+schedule:
+  interval: "hourly"
+  max_retries: 3
+  run_immediately: true
+""")
+            return 1
+            
+        except ValueError as e:
+            print(f"❌ Configuration Error: {e}")
+            return 1
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            if verbose:
+                import traceback
+                traceback.print_exc()
+            return 1
+            
+    @staticmethod
+    def add_schedule_arguments(subparsers):
+        """
+        Add schedule subcommand and arguments to parser.
+        
+        Args:
+            subparsers: Subparsers object from argparse
+        """
+        schedule_parser = subparsers.add_parser(
+            'schedule',
+            help='Schedule an agent to run continuously at regular intervals'
+        )
+        
+        schedule_parser.add_argument(
+            'schedule_yaml',
+            nargs='?',
+            default='agents.yaml',
+            help='Path to agents.yaml file (default: agents.yaml)'
+        )
+        
+        schedule_parser.add_argument(
+            '--interval',
+            dest='schedule_interval',
+            type=str,
+            help='Override schedule interval (e.g., "hourly", "*/30m", "daily")'
+        )
+        
+        schedule_parser.add_argument(
+            '--max-retries',
+            dest='schedule_max_retries',
+            type=int,
+            help='Override maximum retry attempts (default: from YAML or 3)'
+        )
+        
+        schedule_parser.add_argument(
+            '--verbose', '-v',
+            action='store_true',
+            help='Enable verbose logging'
+        )
+        
+        schedule_parser.set_defaults(func=AgentSchedulerHandler.handle_schedule_command)
+
+
+def setup_scheduler_cli(subparsers):
+    """
+    Setup scheduler CLI commands.
+    
+    Args:
+        subparsers: Subparsers object from argparse
+    """
+    AgentSchedulerHandler.add_schedule_arguments(subparsers)

src/praisonai/praisonai/cli/features/at_mentions.py

@@ -0,0 +1,416 @@
+"""
+@ Mention Autocomplete for PraisonAI CLI.
+
+Provides file/directory autocomplete when user types @.
+Uses only stdlib imports for zero performance impact.
+
+Features:
+- Detect @ trigger in input
+- Fuzzy search files/directories
+- Cache results for performance
+- Integrate with prompt_toolkit
+"""
+
+import os
+import time
+import fnmatch
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Tuple
+
+
+# ============================================================================
+# Data Classes
+# ============================================================================
+
+@dataclass
+class AtMentionContext:
+    """Context for an @ mention in user input."""
+    is_active: bool
+    query: str
+    start_pos: int
+    mention_type: str = "file"  # file, directory, web, etc.
+
+
+@dataclass
+class FileSuggestion:
+    """A file or directory suggestion."""
+    path: str
+    file_type: str  # "file" or "directory"
+    score: int = 100
+    display: str = ""
+    
+    def __post_init__(self):
+        if not self.display:
+            self.display = self.path
+
+
+# ============================================================================
+# @ Mention Detection
+# ============================================================================
+
+def detect_at_mention(text: str, cursor_pos: int) -> Optional[AtMentionContext]:
+    """
+    Detect if cursor is within an @ mention context.
+    
+    Scans backward from cursor to find @ symbol.
+    Returns None if not in @ context.
+    
+    Args:
+        text: Full input text
+        cursor_pos: Current cursor position
+        
+    Returns:
+        AtMentionContext if in @ mention, None otherwise
+    """
+    if cursor_pos <= 0 or cursor_pos > len(text):
+        return None
+    
+    # Scan backward from cursor to find @
+    at_pos = -1
+    for i in range(cursor_pos - 1, -1, -1):
+        char = text[i]
+        
+        # Found @
+        if char == '@':
+            at_pos = i
+            break
+        
+        # Space/newline breaks @ context
+        if char in ' \t\n\r':
+            return None
+    
+    if at_pos == -1:
+        return None
+    
+    # Extract query between @ and cursor
+    query = text[at_pos + 1:cursor_pos]
+    
+    return AtMentionContext(
+        is_active=True,
+        query=query,
+        start_pos=at_pos
+    )
+
+
+# ============================================================================
+# File Search Service
+# ============================================================================
+
+class FileSearchService:
+    """
+    Service for searching files in a directory.
+    
+    Features:
+    - Walk directory tree
+    - Fuzzy match file paths
+    - Cache results with TTL
+    - Respect .gitignore (basic)
+    """
+    
+    def __init__(
+        self,
+        root_dir: str,
+        cache_ttl: int = 30,
+        max_depth: int = 5,
+        ignore_patterns: Optional[List[str]] = None
+    ):
+        self._root = os.path.abspath(root_dir)
+        self._cache_ttl = cache_ttl
+        self._max_depth = max_depth
+        self._ignore_patterns = ignore_patterns or [
+            '.git', '__pycache__', 'node_modules', '.venv', 'venv',
+            '*.pyc', '*.pyo', '.DS_Store', '*.egg-info'
+        ]
+        
+        # Cache: query -> (results, timestamp)
+        self._cache: Dict[str, Tuple[List[FileSuggestion], float]] = {}
+        
+        # File list cache
+        self._file_list: Optional[List[str]] = None
+        self._file_list_time: float = 0
+    
+    def _should_ignore(self, name: str) -> bool:
+        """Check if file/dir should be ignored."""
+        for pattern in self._ignore_patterns:
+            if fnmatch.fnmatch(name, pattern):
+                return True
+        return False
+    
+    def _get_file_list(self) -> List[str]:
+        """Get list of all files (cached)."""
+        now = time.time()
+        
+        # Return cached if fresh
+        if self._file_list is not None and (now - self._file_list_time) < self._cache_ttl:
+            return self._file_list
+        
+        files = []
+        
+        try:
+            for root, dirs, filenames in os.walk(self._root):
+                # Calculate depth
+                rel_root = os.path.relpath(root, self._root)
+                depth = 0 if rel_root == '.' else rel_root.count(os.sep) + 1
+                
+                if depth > self._max_depth:
+                    dirs.clear()  # Don't descend further
+                    continue
+                
+                # Filter ignored directories
+                dirs[:] = [d for d in dirs if not self._should_ignore(d)]
+                
+                # Add directories
+                for d in dirs:
+                    rel_path = os.path.relpath(os.path.join(root, d), self._root)
+                    files.append(rel_path + os.sep)
+                
+                # Add files
+                for f in filenames:
+                    if not self._should_ignore(f):
+                        rel_path = os.path.relpath(os.path.join(root, f), self._root)
+                        files.append(rel_path)
+        except OSError:
+            pass
+        
+        self._file_list = files
+        self._file_list_time = now
+        return files
+    
+    def _fuzzy_match(self, text: str, query: str) -> int:
+        """
+        Simple fuzzy match scoring.
+        
+        Returns score 0-100, higher is better.
+        """
+        if not query:
+            return 50  # Default score for empty query
+        
+        text_lower = text.lower()
+        query_lower = query.lower()
+        
+        # Exact match
+        if text_lower == query_lower:
+            return 100
+        
+        # Starts with
+        if text_lower.startswith(query_lower):
+            return 90
+        
+        # Contains
+        if query_lower in text_lower:
+            return 80
+        
+        # Fuzzy: all query chars appear in order
+        text_idx = 0
+        query_idx = 0
+        matches = 0
+        
+        while text_idx < len(text_lower) and query_idx < len(query_lower):
+            if text_lower[text_idx] == query_lower[query_idx]:
+                matches += 1
+                query_idx += 1
+            text_idx += 1
+        
+        if query_idx == len(query_lower):
+            # All query chars found
+            return 50 + int(30 * matches / len(text))
+        
+        return 0
+    
+    def search(self, query: str, max_results: int = 20) -> List[FileSuggestion]:
+        """
+        Search for files matching query.
+        
+        Args:
+            query: Search query (fuzzy matched)
+            max_results: Maximum results to return
+            
+        Returns:
+            List of FileSuggestion sorted by score
+        """
+        # Check cache
+        cache_key = f"{query}:{max_results}"
+        now = time.time()
+        
+        if cache_key in self._cache:
+            results, cached_time = self._cache[cache_key]
+            if (now - cached_time) < self._cache_ttl:
+                return results
+        
+        # Get all files
+        all_files = self._get_file_list()
+        
+        # Score and filter
+        scored: List[Tuple[int, str]] = []
+        for path in all_files:
+            score = self._fuzzy_match(path, query)
+            if score > 0:
+                scored.append((score, path))
+        
+        # Sort by score descending
+        scored.sort(key=lambda x: (-x[0], x[1]))
+        
+        # Build results
+        results = []
+        for score, path in scored[:max_results]:
+            file_type = "directory" if path.endswith(os.sep) else "file"
+            results.append(FileSuggestion(
+                path=path,
+                file_type=file_type,
+                score=score
+            ))
+        
+        # Cache results
+        self._cache[cache_key] = (results, now)
+        
+        return results
+    
+    def clear_cache(self) -> None:
+        """Clear all caches."""
+        self._cache.clear()
+        self._file_list = None
+
+
+# ============================================================================
+# Completers for prompt_toolkit
+# ============================================================================
+
+# Lazy import to avoid performance impact
+_Completer = None
+_Completion = None
+
+def _get_prompt_toolkit():
+    """Lazy import prompt_toolkit."""
+    global _Completer, _Completion
+    if _Completer is None:
+        from prompt_toolkit.completion import Completer, Completion
+        _Completer = Completer
+        _Completion = Completion
+    return _Completer, _Completion
+
+
+class AtMentionCompleter:
+    """
+    Completer for @ mentions.
+    
+    Shows file suggestions when user types @.
+    Implements prompt_toolkit Completer interface.
+    """
+    
+    def __init__(self, root_dir: str):
+        self._file_service = FileSearchService(root_dir)
+    
+    def get_completions(self, document, complete_event):
+        """Get completions for @ mentions."""
+        _, Completion = _get_prompt_toolkit()
+        
+        text = document.text_before_cursor
+        cursor_pos = len(text)
+        
+        # Detect @ context
+        context = detect_at_mention(text, cursor_pos)
+        if context is None or not context.is_active:
+            return
+        
+        # Search files
+        results = self._file_service.search(context.query, max_results=15)
+        
+        # Yield completions
+        for suggestion in results:
+            # Icon based on type
+            icon = "📁 " if suggestion.file_type == "directory" else "📄 "
+            display = f"{icon}{suggestion.path}"
+            
+            # Calculate replacement position
+            # Replace from @ to cursor
+            start_position = -(cursor_pos - context.start_pos)
+            
+            yield Completion(
+                text=f"@{suggestion.path}",
+                start_position=start_position,
+                display=display
+            )
+
+
+def create_combined_completer(commands: List[str], root_dir: str):
+    """
+    Factory function to create a CombinedCompleter.
+    
+    Returns a proper Completer subclass that handles both / and @.
+    """
+    Completer, Completion = _get_prompt_toolkit()
+    file_service = FileSearchService(root_dir)
+    
+    class CombinedCompleter(Completer):
+        """
+        Combined completer for both / commands and @ mentions.
+        
+        Properly inherits from prompt_toolkit Completer.
+        """
+        
+        def get_completions(self, document, complete_event):
+            """Get completions for / or @."""
+            text = document.text_before_cursor.lstrip()
+            
+            # Check for slash command
+            if text.startswith('/'):
+                cmd_text = text[1:].lower()
+                for cmd in commands:
+                    if cmd.lower().startswith(cmd_text):
+                        yield Completion(
+                            f'/{cmd}',
+                            start_position=-len(text),
+                            display=f'/{cmd}'
+                        )
+                return
+            
+            # Check for @ mention
+            full_text = document.text_before_cursor
+            cursor_pos = len(full_text)
+            
+            context = detect_at_mention(full_text, cursor_pos)
+            if context is None or not context.is_active:
+                return
+            
+            # Search files
+            results = file_service.search(context.query, max_results=15)
+            
+            # Yield completions
+            for suggestion in results:
+                icon = "📁 " if suggestion.file_type == "directory" else "📄 "
+                display = f"{icon}{suggestion.path}"
+                start_position = -(cursor_pos - context.start_pos)
+                
+                yield Completion(
+                    text=f"@{suggestion.path}",
+                    start_position=start_position,
+                    display=display
+                )
+    
+    return CombinedCompleter()
+
+
+# Backward compatible alias
+class CombinedCompleter:
+    """
+    Wrapper class for backward compatibility.
+    
+    Use create_combined_completer() for proper Completer subclass.
+    """
+    
+    def __new__(cls, commands: List[str], root_dir: str):
+        return create_combined_completer(commands, root_dir)
+
+
+# ============================================================================
+# Exports
+# ============================================================================
+
+__all__ = [
+    'AtMentionContext',
+    'FileSuggestion',
+    'detect_at_mention',
+    'FileSearchService',
+    'AtMentionCompleter',
+    'CombinedCompleter',
+]

src/praisonai/praisonai/cli/features/autonomy_mode.py

@@ -0,0 +1,490 @@
+"""
+Autonomy Modes for PraisonAI CLI.
+
+Inspired by Codex CLI's approval modes and Gemini CLI's approval settings.
+Provides configurable autonomy levels: suggest, auto-edit, full-auto.
+
+Architecture:
+- AutonomyMode: Enum for different autonomy levels
+- AutonomyPolicy: Policy configuration for each mode
+- AutonomyManager: Manages mode transitions and approvals
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Optional, Set
+from enum import Enum
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AutonomyMode(Enum):
+    """
+    Autonomy levels for agent execution.
+    
+    Inspired by Codex CLI's approval modes:
+    - SUGGEST: Read-only, requires approval for all changes
+    - AUTO_EDIT: Auto-approve file edits, require approval for commands
+    - FULL_AUTO: Auto-approve everything (YOLO mode)
+    """
+    SUGGEST = "suggest"          # Default: ask for approval on everything
+    AUTO_EDIT = "auto_edit"      # Auto-approve file edits only
+    FULL_AUTO = "full_auto"      # Auto-approve everything (dangerous)
+    
+    @classmethod
+    def from_string(cls, value: str) -> "AutonomyMode":
+        """Parse mode from string."""
+        value = value.lower().strip().replace("-", "_")
+        for mode in cls:
+            if mode.value == value:
+                return mode
+        raise ValueError(f"Unknown autonomy mode: {value}")
+
+
+class ActionType(Enum):
+    """Types of actions that require approval."""
+    FILE_READ = "file_read"
+    FILE_WRITE = "file_write"
+    FILE_DELETE = "file_delete"
+    SHELL_COMMAND = "shell_command"
+    NETWORK_REQUEST = "network_request"
+    CODE_EXECUTION = "code_execution"
+    GIT_OPERATION = "git_operation"
+    TOOL_CALL = "tool_call"
+
+
+@dataclass
+class ActionRequest:
+    """
+    Request for an action that may require approval.
+    
+    Attributes:
+        action_type: Type of action
+        description: Human-readable description
+        details: Additional details (file path, command, etc.)
+        risk_level: Estimated risk (low, medium, high)
+        reversible: Whether the action can be undone
+    """
+    action_type: ActionType
+    description: str
+    details: Dict[str, Any] = field(default_factory=dict)
+    risk_level: str = "medium"
+    reversible: bool = True
+    
+    def __str__(self) -> str:
+        return f"{self.action_type.value}: {self.description}"
+
+
+@dataclass
+class ApprovalResult:
+    """Result of an approval request."""
+    approved: bool
+    reason: Optional[str] = None
+    modified_action: Optional[ActionRequest] = None
+    remember_choice: bool = False
+
+
+@dataclass
+class AutonomyPolicy:
+    """
+    Policy configuration for autonomy mode.
+    
+    Defines which actions are auto-approved, require approval,
+    or are blocked entirely.
+    """
+    mode: AutonomyMode
+    
+    # Actions that are auto-approved
+    auto_approve: Set[ActionType] = field(default_factory=set)
+    
+    # Actions that always require approval
+    require_approval: Set[ActionType] = field(default_factory=set)
+    
+    # Actions that are blocked entirely
+    blocked: Set[ActionType] = field(default_factory=set)
+    
+    # Trusted paths for file operations
+    trusted_paths: Set[str] = field(default_factory=set)
+    
+    # Trusted commands (patterns)
+    trusted_commands: Set[str] = field(default_factory=set)
+    
+    # Maximum auto-approved actions before requiring confirmation
+    max_auto_actions: int = 10
+    
+    # Whether to show what would be done in suggest mode
+    show_preview: bool = True
+    
+    @classmethod
+    def for_mode(cls, mode: AutonomyMode) -> "AutonomyPolicy":
+        """Create default policy for a given mode."""
+        if mode == AutonomyMode.SUGGEST:
+            return cls(
+                mode=mode,
+                auto_approve={ActionType.FILE_READ},
+                require_approval={
+                    ActionType.FILE_WRITE,
+                    ActionType.FILE_DELETE,
+                    ActionType.SHELL_COMMAND,
+                    ActionType.CODE_EXECUTION,
+                    ActionType.GIT_OPERATION,
+                    ActionType.NETWORK_REQUEST,
+                    ActionType.TOOL_CALL,
+                },
+                blocked=set(),
+                show_preview=True
+            )
+        elif mode == AutonomyMode.AUTO_EDIT:
+            return cls(
+                mode=mode,
+                auto_approve={
+                    ActionType.FILE_READ,
+                    ActionType.FILE_WRITE,
+                    ActionType.TOOL_CALL,
+                },
+                require_approval={
+                    ActionType.FILE_DELETE,
+                    ActionType.SHELL_COMMAND,
+                    ActionType.CODE_EXECUTION,
+                    ActionType.GIT_OPERATION,
+                    ActionType.NETWORK_REQUEST,
+                },
+                blocked=set(),
+                show_preview=True
+            )
+        elif mode == AutonomyMode.FULL_AUTO:
+            return cls(
+                mode=mode,
+                auto_approve={
+                    ActionType.FILE_READ,
+                    ActionType.FILE_WRITE,
+                    ActionType.FILE_DELETE,
+                    ActionType.SHELL_COMMAND,
+                    ActionType.CODE_EXECUTION,
+                    ActionType.GIT_OPERATION,
+                    ActionType.NETWORK_REQUEST,
+                    ActionType.TOOL_CALL,
+                },
+                require_approval=set(),
+                blocked=set(),
+                show_preview=False,
+                max_auto_actions=100
+            )
+        else:
+            raise ValueError(f"Unknown mode: {mode}")
+
+
+class AutonomyManager:
+    """
+    Manages autonomy mode and approval flow.
+    
+    Handles:
+    - Mode transitions
+    - Approval requests
+    - Action tracking
+    - Policy enforcement
+    """
+    
+    def __init__(
+        self,
+        mode: AutonomyMode = AutonomyMode.SUGGEST,
+        policy: Optional[AutonomyPolicy] = None,
+        approval_callback: Optional[Callable[[ActionRequest], ApprovalResult]] = None,
+        verbose: bool = False
+    ):
+        self.mode = mode
+        self.policy = policy or AutonomyPolicy.for_mode(mode)
+        self.approval_callback = approval_callback or self._default_approval
+        self.verbose = verbose
+        
+        # Tracking
+        self._action_count = 0
+        self._auto_approved_count = 0
+        self._denied_count = 0
+        self._remembered_approvals: Dict[str, bool] = {}
+    
+    def set_mode(self, mode: AutonomyMode) -> None:
+        """Change the autonomy mode."""
+        old_mode = self.mode
+        self.mode = mode
+        self.policy = AutonomyPolicy.for_mode(mode)
+        
+        if self.verbose:
+            logger.info(f"Autonomy mode changed: {old_mode.value} -> {mode.value}")
+    
+    def request_approval(self, action: ActionRequest) -> ApprovalResult:
+        """
+        Request approval for an action.
+        
+        Returns:
+            ApprovalResult with approval decision
+        """
+        self._action_count += 1
+        
+        # Check if blocked
+        if action.action_type in self.policy.blocked:
+            self._denied_count += 1
+            return ApprovalResult(
+                approved=False,
+                reason=f"Action type '{action.action_type.value}' is blocked by policy"
+            )
+        
+        # Check remembered approvals
+        action_key = self._get_action_key(action)
+        if action_key in self._remembered_approvals:
+            approved = self._remembered_approvals[action_key]
+            if approved:
+                self._auto_approved_count += 1
+            else:
+                self._denied_count += 1
+            return ApprovalResult(approved=approved, reason="Remembered choice")
+        
+        # Check if auto-approved
+        if action.action_type in self.policy.auto_approve:
+            # Check max auto actions
+            if self._auto_approved_count >= self.policy.max_auto_actions:
+                # Force approval after max auto actions
+                return self._request_user_approval(action)
+            
+            self._auto_approved_count += 1
+            return ApprovalResult(approved=True, reason="Auto-approved by policy")
+        
+        # Check if requires approval
+        if action.action_type in self.policy.require_approval:
+            return self._request_user_approval(action)
+        
+        # Default: require approval for unknown action types
+        return self._request_user_approval(action)
+    
+    def _request_user_approval(self, action: ActionRequest) -> ApprovalResult:
+        """Request approval from user via callback."""
+        result = self.approval_callback(action)
+        
+        if result.remember_choice:
+            action_key = self._get_action_key(action)
+            self._remembered_approvals[action_key] = result.approved
+        
+        if result.approved:
+            self._auto_approved_count += 1
+        else:
+            self._denied_count += 1
+        
+        return result
+    
+    def _get_action_key(self, action: ActionRequest) -> str:
+        """Generate a key for remembering approval decisions."""
+        # Use action type and relevant details
+        key_parts = [action.action_type.value]
+        
+        if "path" in action.details:
+            key_parts.append(action.details["path"])
+        if "command" in action.details:
+            key_parts.append(action.details["command"])
+        
+        return ":".join(key_parts)
+    
+    def _default_approval(self, action: ActionRequest) -> ApprovalResult:
+        """Default approval callback using console input."""
+        from rich.console import Console
+        from rich.panel import Panel
+        from rich.prompt import Confirm
+        
+        console = Console()
+        
+        # Build action description
+        risk_color = {
+            "low": "green",
+            "medium": "yellow",
+            "high": "red"
+        }.get(action.risk_level, "white")
+        
+        details_str = "\n".join(
+            f"  {k}: {v}" for k, v in action.details.items()
+        ) if action.details else "  (no details)"
+        
+        panel_content = f"""
+[bold]{action.description}[/bold]
+
+Type: {action.action_type.value}
+Risk: [{risk_color}]{action.risk_level}[/{risk_color}]
+Reversible: {"Yes" if action.reversible else "No"}
+
+Details:
+{details_str}
+"""
+        
+        console.print(Panel(
+            panel_content,
+            title="🔒 Approval Required",
+            border_style="yellow"
+        ))
+        
+        approved = Confirm.ask("Approve this action?", default=False)
+        remember = False
+        
+        if approved:
+            remember = Confirm.ask("Remember this choice for similar actions?", default=False)
+        
+        return ApprovalResult(
+            approved=approved,
+            remember_choice=remember
+        )
+    
+    def get_stats(self) -> Dict[str, int]:
+        """Get approval statistics."""
+        return {
+            "total_actions": self._action_count,
+            "auto_approved": self._auto_approved_count,
+            "denied": self._denied_count,
+            "remembered": len(self._remembered_approvals)
+        }
+    
+    def reset_stats(self) -> None:
+        """Reset approval statistics."""
+        self._action_count = 0
+        self._auto_approved_count = 0
+        self._denied_count = 0
+    
+    def clear_remembered(self) -> None:
+        """Clear remembered approval decisions."""
+        self._remembered_approvals.clear()
+
+
+# ============================================================================
+# CLI Integration Handler
+# ============================================================================
+
+class AutonomyModeHandler:
+    """
+    Handler for integrating autonomy modes with PraisonAI CLI.
+    """
+    
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self._manager: Optional[AutonomyManager] = None
+    
+    @property
+    def feature_name(self) -> str:
+        return "autonomy_mode"
+    
+    def initialize(
+        self,
+        mode: str = "suggest",
+        approval_callback: Optional[Callable[[ActionRequest], ApprovalResult]] = None
+    ) -> AutonomyManager:
+        """
+        Initialize the autonomy manager.
+        
+        Args:
+            mode: Autonomy mode string (suggest, auto_edit, full_auto)
+            approval_callback: Optional custom approval callback
+            
+        Returns:
+            Configured AutonomyManager
+        """
+        try:
+            autonomy_mode = AutonomyMode.from_string(mode)
+        except ValueError:
+            logger.warning(f"Unknown mode '{mode}', defaulting to 'suggest'")
+            autonomy_mode = AutonomyMode.SUGGEST
+        
+        self._manager = AutonomyManager(
+            mode=autonomy_mode,
+            approval_callback=approval_callback,
+            verbose=self.verbose
+        )
+        
+        if self.verbose:
+            from rich import print as rprint
+            rprint(f"[cyan]Autonomy mode: {autonomy_mode.value}[/cyan]")
+        
+        return self._manager
+    
+    def get_manager(self) -> Optional[AutonomyManager]:
+        """Get the current autonomy manager."""
+        return self._manager
+    
+    def request_approval(self, action: ActionRequest) -> ApprovalResult:
+        """Request approval for an action."""
+        if not self._manager:
+            self._manager = self.initialize()
+        
+        return self._manager.request_approval(action)
+    
+    def set_mode(self, mode: str) -> None:
+        """Change the autonomy mode."""
+        if not self._manager:
+            self.initialize(mode)
+        else:
+            try:
+                autonomy_mode = AutonomyMode.from_string(mode)
+                self._manager.set_mode(autonomy_mode)
+            except ValueError as e:
+                logger.error(f"Failed to set mode: {e}")
+    
+    def get_mode(self) -> str:
+        """Get the current autonomy mode."""
+        if self._manager:
+            return self._manager.mode.value
+        return AutonomyMode.SUGGEST.value
+
+
+# ============================================================================
+# Convenience Functions
+# ============================================================================
+
+def create_file_write_action(path: str, content_preview: str = "") -> ActionRequest:
+    """Create an action request for file write."""
+    return ActionRequest(
+        action_type=ActionType.FILE_WRITE,
+        description=f"Write to file: {path}",
+        details={
+            "path": path,
+            "preview": content_preview[:200] if content_preview else "(no preview)"
+        },
+        risk_level="medium",
+        reversible=True
+    )
+
+
+def create_shell_command_action(command: str, cwd: str = ".") -> ActionRequest:
+    """Create an action request for shell command."""
+    # Assess risk based on command
+    dangerous_patterns = ["rm ", "sudo ", "chmod ", "chown ", "> /", "| sh", "curl |"]
+    risk = "high" if any(p in command for p in dangerous_patterns) else "medium"
+    
+    return ActionRequest(
+        action_type=ActionType.SHELL_COMMAND,
+        description=f"Execute command: {command}",
+        details={
+            "command": command,
+            "cwd": cwd
+        },
+        risk_level=risk,
+        reversible=False
+    )
+
+
+def create_git_action(operation: str, details: Dict[str, Any] = None) -> ActionRequest:
+    """Create an action request for git operation."""
+    return ActionRequest(
+        action_type=ActionType.GIT_OPERATION,
+        description=f"Git {operation}",
+        details=details or {},
+        risk_level="low" if operation in ["status", "log", "diff"] else "medium",
+        reversible=operation not in ["push", "force-push"]
+    )
+
+
+def create_tool_call_action(tool_name: str, args: Dict[str, Any] = None) -> ActionRequest:
+    """Create an action request for tool call."""
+    return ActionRequest(
+        action_type=ActionType.TOOL_CALL,
+        description=f"Call tool: {tool_name}",
+        details={
+            "tool": tool_name,
+            "args": args or {}
+        },
+        risk_level="low",
+        reversible=True
+    )

src/praisonai/praisonai/cli/features/cost_tracker.py

@@ -0,0 +1,514 @@
+"""
+Cost Tracking System for PraisonAI CLI.
+
+Inspired by Aider's cost tracking and Gemini CLI's stats command.
+Provides real-time cost and token usage tracking.
+
+Architecture:
+- CostTracker: Tracks tokens and costs per session
+- ModelPricing: Pricing data for different models
+- UsageStats: Aggregated usage statistics
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+import logging
+import json
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Model Pricing Data
+# ============================================================================
+
+@dataclass
+class ModelPricing:
+    """
+    Pricing information for a model.
+    
+    Prices are per 1M tokens (as commonly quoted).
+    """
+    model_name: str
+    input_price_per_1m: float  # Price per 1M input tokens
+    output_price_per_1m: float  # Price per 1M output tokens
+    context_window: int = 128000
+    
+    def calculate_cost(self, input_tokens: int, output_tokens: int) -> float:
+        """Calculate cost for given token counts."""
+        input_cost = (input_tokens / 1_000_000) * self.input_price_per_1m
+        output_cost = (output_tokens / 1_000_000) * self.output_price_per_1m
+        return input_cost + output_cost
+
+
+# Default pricing for common models (as of late 2024)
+DEFAULT_PRICING: Dict[str, ModelPricing] = {
+    # OpenAI models
+    "gpt-4o": ModelPricing("gpt-4o", 2.50, 10.00, 128000),
+    "gpt-4o-mini": ModelPricing("gpt-4o-mini", 0.15, 0.60, 128000),
+    "gpt-4-turbo": ModelPricing("gpt-4-turbo", 10.00, 30.00, 128000),
+    "gpt-4": ModelPricing("gpt-4", 30.00, 60.00, 8192),
+    "gpt-3.5-turbo": ModelPricing("gpt-3.5-turbo", 0.50, 1.50, 16385),
+    "o1": ModelPricing("o1", 15.00, 60.00, 200000),
+    "o1-mini": ModelPricing("o1-mini", 3.00, 12.00, 128000),
+    "o1-preview": ModelPricing("o1-preview", 15.00, 60.00, 128000),
+    "o3-mini": ModelPricing("o3-mini", 1.10, 4.40, 200000),
+    
+    # Anthropic models
+    "claude-3-5-sonnet-20241022": ModelPricing("claude-3-5-sonnet", 3.00, 15.00, 200000),
+    "claude-3-5-sonnet": ModelPricing("claude-3-5-sonnet", 3.00, 15.00, 200000),
+    "claude-3-opus": ModelPricing("claude-3-opus", 15.00, 75.00, 200000),
+    "claude-3-sonnet": ModelPricing("claude-3-sonnet", 3.00, 15.00, 200000),
+    "claude-3-haiku": ModelPricing("claude-3-haiku", 0.25, 1.25, 200000),
+    
+    # Google models
+    "gemini-2.0-flash": ModelPricing("gemini-2.0-flash", 0.10, 0.40, 1000000),
+    "gemini-1.5-pro": ModelPricing("gemini-1.5-pro", 1.25, 5.00, 2000000),
+    "gemini-1.5-flash": ModelPricing("gemini-1.5-flash", 0.075, 0.30, 1000000),
+    
+    # Default fallback
+    "default": ModelPricing("default", 1.00, 3.00, 128000),
+}
+
+
+def get_pricing(model_name: str) -> ModelPricing:
+    """Get pricing for a model, with fallback to default."""
+    # Try exact match
+    if model_name in DEFAULT_PRICING:
+        return DEFAULT_PRICING[model_name]
+    
+    # Try partial match
+    model_lower = model_name.lower()
+    for key, pricing in DEFAULT_PRICING.items():
+        if key in model_lower or model_lower in key:
+            return pricing
+    
+    # Return default
+    logger.debug(f"No pricing found for model '{model_name}', using default")
+    return DEFAULT_PRICING["default"]
+
+
+# ============================================================================
+# Usage Statistics
+# ============================================================================
+
+@dataclass
+class TokenUsage:
+    """Token usage for a single request."""
+    input_tokens: int = 0
+    output_tokens: int = 0
+    total_tokens: int = 0
+    cached_tokens: int = 0
+    
+    def __post_init__(self):
+        if self.total_tokens == 0:
+            self.total_tokens = self.input_tokens + self.output_tokens
+
+
+@dataclass
+class RequestStats:
+    """Statistics for a single request."""
+    timestamp: datetime
+    model: str
+    usage: TokenUsage
+    cost: float
+    duration_ms: float = 0.0
+    prompt_preview: str = ""
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "timestamp": self.timestamp.isoformat(),
+            "model": self.model,
+            "input_tokens": self.usage.input_tokens,
+            "output_tokens": self.usage.output_tokens,
+            "total_tokens": self.usage.total_tokens,
+            "cached_tokens": self.usage.cached_tokens,
+            "cost": self.cost,
+            "duration_ms": self.duration_ms,
+        }
+
+
+@dataclass
+class SessionStats:
+    """Aggregated statistics for a session."""
+    session_id: str
+    start_time: datetime
+    end_time: Optional[datetime] = None
+    
+    total_requests: int = 0
+    total_input_tokens: int = 0
+    total_output_tokens: int = 0
+    total_tokens: int = 0
+    total_cached_tokens: int = 0
+    total_cost: float = 0.0
+    total_duration_ms: float = 0.0
+    
+    models_used: Dict[str, int] = field(default_factory=dict)
+    
+    def add_request(self, stats: RequestStats) -> None:
+        """Add request statistics to session totals."""
+        self.total_requests += 1
+        self.total_input_tokens += stats.usage.input_tokens
+        self.total_output_tokens += stats.usage.output_tokens
+        self.total_tokens += stats.usage.total_tokens
+        self.total_cached_tokens += stats.usage.cached_tokens
+        self.total_cost += stats.cost
+        self.total_duration_ms += stats.duration_ms
+        
+        # Track model usage
+        if stats.model not in self.models_used:
+            self.models_used[stats.model] = 0
+        self.models_used[stats.model] += 1
+    
+    @property
+    def duration_seconds(self) -> float:
+        """Get session duration in seconds."""
+        end = self.end_time or datetime.now()
+        return (end - self.start_time).total_seconds()
+    
+    @property
+    def avg_tokens_per_request(self) -> float:
+        """Get average tokens per request."""
+        if self.total_requests == 0:
+            return 0.0
+        return self.total_tokens / self.total_requests
+    
+    @property
+    def avg_cost_per_request(self) -> float:
+        """Get average cost per request."""
+        if self.total_requests == 0:
+            return 0.0
+        return self.total_cost / self.total_requests
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "session_id": self.session_id,
+            "start_time": self.start_time.isoformat(),
+            "end_time": self.end_time.isoformat() if self.end_time else None,
+            "duration_seconds": self.duration_seconds,
+            "total_requests": self.total_requests,
+            "total_input_tokens": self.total_input_tokens,
+            "total_output_tokens": self.total_output_tokens,
+            "total_tokens": self.total_tokens,
+            "total_cached_tokens": self.total_cached_tokens,
+            "total_cost": self.total_cost,
+            "avg_tokens_per_request": self.avg_tokens_per_request,
+            "avg_cost_per_request": self.avg_cost_per_request,
+            "models_used": self.models_used,
+        }
+
+
+# ============================================================================
+# Cost Tracker
+# ============================================================================
+
+class CostTracker:
+    """
+    Tracks costs and token usage for a session.
+    
+    Features:
+    - Real-time cost tracking
+    - Per-model statistics
+    - Session history
+    - Export to JSON
+    """
+    
+    def __init__(
+        self,
+        session_id: Optional[str] = None,
+        pricing: Optional[Dict[str, ModelPricing]] = None,
+        verbose: bool = False
+    ):
+        self.session_id = session_id or self._generate_session_id()
+        self.pricing = pricing or DEFAULT_PRICING
+        self.verbose = verbose
+        
+        self.session_stats = SessionStats(
+            session_id=self.session_id,
+            start_time=datetime.now()
+        )
+        self.request_history: List[RequestStats] = []
+    
+    def _generate_session_id(self) -> str:
+        """Generate a unique session ID."""
+        import uuid
+        return str(uuid.uuid4())[:8]
+    
+    def track_request(
+        self,
+        model: str,
+        input_tokens: int,
+        output_tokens: int,
+        cached_tokens: int = 0,
+        duration_ms: float = 0.0,
+        prompt_preview: str = ""
+    ) -> RequestStats:
+        """
+        Track a single request.
+        
+        Returns:
+            RequestStats for the tracked request
+        """
+        usage = TokenUsage(
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            cached_tokens=cached_tokens
+        )
+        
+        # Calculate cost
+        pricing = get_pricing(model)
+        cost = pricing.calculate_cost(input_tokens, output_tokens)
+        
+        # Create request stats
+        stats = RequestStats(
+            timestamp=datetime.now(),
+            model=model,
+            usage=usage,
+            cost=cost,
+            duration_ms=duration_ms,
+            prompt_preview=prompt_preview[:100] if prompt_preview else ""
+        )
+        
+        # Update session stats
+        self.session_stats.add_request(stats)
+        self.request_history.append(stats)
+        
+        if self.verbose:
+            logger.info(
+                f"Request tracked: {model} - "
+                f"{usage.total_tokens} tokens, ${cost:.4f}"
+            )
+        
+        return stats
+    
+    def track_from_response(
+        self,
+        model: str,
+        response: Any,
+        duration_ms: float = 0.0
+    ) -> Optional[RequestStats]:
+        """
+        Track request from LLM response object.
+        
+        Handles various response formats from different providers.
+        """
+        try:
+            # Try to extract usage from response
+            usage = None
+            
+            # OpenAI format
+            if hasattr(response, 'usage'):
+                usage = response.usage
+                input_tokens = getattr(usage, 'prompt_tokens', 0)
+                output_tokens = getattr(usage, 'completion_tokens', 0)
+                cached_tokens = getattr(usage, 'cached_tokens', 0)
+            # Dict format
+            elif isinstance(response, dict) and 'usage' in response:
+                usage = response['usage']
+                input_tokens = usage.get('prompt_tokens', 0)
+                output_tokens = usage.get('completion_tokens', 0)
+                cached_tokens = usage.get('cached_tokens', 0)
+            else:
+                logger.debug("Could not extract usage from response")
+                return None
+            
+            return self.track_request(
+                model=model,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                cached_tokens=cached_tokens,
+                duration_ms=duration_ms
+            )
+        except Exception as e:
+            logger.error(f"Error tracking response: {e}")
+            return None
+    
+    def get_current_stats(self) -> SessionStats:
+        """Get current session statistics."""
+        return self.session_stats
+    
+    def get_total_cost(self) -> float:
+        """Get total cost for the session."""
+        return self.session_stats.total_cost
+    
+    def get_total_tokens(self) -> int:
+        """Get total tokens for the session."""
+        return self.session_stats.total_tokens
+    
+    def get_request_count(self) -> int:
+        """Get total request count."""
+        return self.session_stats.total_requests
+    
+    def format_summary(self) -> str:
+        """Format a summary of the session statistics."""
+        stats = self.session_stats
+        
+        lines = [
+            f"Session: {stats.session_id}",
+            f"Duration: {stats.duration_seconds:.1f}s",
+            f"Requests: {stats.total_requests}",
+            "",
+            "Tokens:",
+            f"  Input:  {stats.total_input_tokens:,}",
+            f"  Output: {stats.total_output_tokens:,}",
+            f"  Total:  {stats.total_tokens:,}",
+            f"  Cached: {stats.total_cached_tokens:,}",
+            "",
+            f"Cost: ${stats.total_cost:.4f}",
+            f"Avg per request: ${stats.avg_cost_per_request:.4f}",
+        ]
+        
+        if stats.models_used:
+            lines.append("")
+            lines.append("Models used:")
+            for model, count in stats.models_used.items():
+                lines.append(f"  {model}: {count} requests")
+        
+        return "\n".join(lines)
+    
+    def print_summary(self) -> None:
+        """Print a formatted summary to console."""
+        from rich.console import Console
+        from rich.panel import Panel
+        from rich.table import Table
+        
+        console = Console()
+        stats = self.session_stats
+        
+        # Create summary table
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Metric")
+        table.add_column("Value", justify="right")
+        
+        table.add_row("Session ID", stats.session_id)
+        table.add_row("Duration", f"{stats.duration_seconds:.1f}s")
+        table.add_row("Requests", str(stats.total_requests))
+        table.add_row("", "")
+        table.add_row("Input Tokens", f"{stats.total_input_tokens:,}")
+        table.add_row("Output Tokens", f"{stats.total_output_tokens:,}")
+        table.add_row("Total Tokens", f"{stats.total_tokens:,}")
+        table.add_row("Cached Tokens", f"{stats.total_cached_tokens:,}")
+        table.add_row("", "")
+        table.add_row("Total Cost", f"${stats.total_cost:.4f}")
+        table.add_row("Avg Cost/Request", f"${stats.avg_cost_per_request:.4f}")
+        
+        console.print(Panel(table, title="💰 Session Statistics", border_style="green"))
+        
+        # Print model breakdown if multiple models used
+        if len(stats.models_used) > 1:
+            model_table = Table(show_header=True, header_style="bold cyan")
+            model_table.add_column("Model")
+            model_table.add_column("Requests", justify="right")
+            
+            for model, count in stats.models_used.items():
+                model_table.add_row(model, str(count))
+            
+            console.print(Panel(model_table, title="Models Used", border_style="blue"))
+    
+    def export_json(self, filepath: Optional[str] = None) -> str:
+        """
+        Export session data to JSON.
+        
+        Args:
+            filepath: Optional file path to write to
+            
+        Returns:
+            JSON string
+        """
+        data = {
+            "session": self.session_stats.to_dict(),
+            "requests": [r.to_dict() for r in self.request_history]
+        }
+        
+        json_str = json.dumps(data, indent=2)
+        
+        if filepath:
+            with open(filepath, 'w') as f:
+                f.write(json_str)
+            logger.info(f"Exported session data to {filepath}")
+        
+        return json_str
+    
+    def end_session(self) -> SessionStats:
+        """Mark the session as ended."""
+        self.session_stats.end_time = datetime.now()
+        return self.session_stats
+
+
+# ============================================================================
+# CLI Integration Handler
+# ============================================================================
+
+class CostTrackerHandler:
+    """
+    Handler for integrating cost tracking with PraisonAI CLI.
+    """
+    
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self._tracker: Optional[CostTracker] = None
+    
+    @property
+    def feature_name(self) -> str:
+        return "cost_tracker"
+    
+    def initialize(self, session_id: Optional[str] = None) -> CostTracker:
+        """Initialize the cost tracker."""
+        self._tracker = CostTracker(
+            session_id=session_id,
+            verbose=self.verbose
+        )
+        
+        if self.verbose:
+            from rich import print as rprint
+            rprint(f"[cyan]Cost tracking enabled for session: {self._tracker.session_id}[/cyan]")
+        
+        return self._tracker
+    
+    def get_tracker(self) -> Optional[CostTracker]:
+        """Get the current cost tracker."""
+        return self._tracker
+    
+    def track_request(
+        self,
+        model: str,
+        input_tokens: int,
+        output_tokens: int,
+        **kwargs
+    ) -> Optional[RequestStats]:
+        """Track a request."""
+        if not self._tracker:
+            self._tracker = self.initialize()
+        
+        return self._tracker.track_request(
+            model=model,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            **kwargs
+        )
+    
+    def get_summary(self) -> Dict[str, Any]:
+        """Get session summary as dict."""
+        if not self._tracker:
+            return {}
+        return self._tracker.session_stats.to_dict()
+    
+    def print_summary(self) -> None:
+        """Print session summary."""
+        if self._tracker:
+            self._tracker.print_summary()
+    
+    def get_cost(self) -> float:
+        """Get total cost."""
+        if self._tracker:
+            return self._tracker.get_total_cost()
+        return 0.0
+    
+    def get_tokens(self) -> int:
+        """Get total tokens."""
+        if self._tracker:
+            return self._tracker.get_total_tokens()
+        return 0

src/praisonai/praisonai/cli/features/git_integration.py

@@ -0,0 +1,651 @@
+"""
+Git Integration System for PraisonAI CLI.
+
+Inspired by Aider's Git integration for auto-commits and change tracking.
+Provides seamless Git operations with AI-generated commit messages.
+
+Architecture:
+- GitManager: Core Git operations using subprocess
+- CommitGenerator: AI-powered commit message generation
+- DiffViewer: Rich diff display
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+from pathlib import Path
+import subprocess
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Data Classes
+# ============================================================================
+
+@dataclass
+class GitStatus:
+    """Git repository status."""
+    branch: str = ""
+    is_clean: bool = True
+    staged_files: List[str] = field(default_factory=list)
+    modified_files: List[str] = field(default_factory=list)
+    untracked_files: List[str] = field(default_factory=list)
+    ahead: int = 0
+    behind: int = 0
+    
+    @property
+    def has_changes(self) -> bool:
+        """Check if there are any changes."""
+        return bool(self.staged_files or self.modified_files or self.untracked_files)
+
+
+@dataclass
+class GitCommit:
+    """Git commit information."""
+    hash: str
+    short_hash: str
+    message: str
+    author: str
+    date: str
+    files_changed: int = 0
+    insertions: int = 0
+    deletions: int = 0
+
+
+@dataclass
+class GitDiff:
+    """Git diff information."""
+    file_path: str
+    additions: int = 0
+    deletions: int = 0
+    content: str = ""
+    is_new: bool = False
+    is_deleted: bool = False
+
+
+# ============================================================================
+# Git Manager
+# ============================================================================
+
+class GitManager:
+    """
+    Manages Git operations using subprocess.
+    
+    Uses subprocess instead of GitPython for lighter dependencies.
+    """
+    
+    def __init__(self, repo_path: Optional[str] = None, verbose: bool = False):
+        self.repo_path = Path(repo_path) if repo_path else Path.cwd()
+        self.verbose = verbose
+        self._git_available = self._check_git()
+    
+    def _check_git(self) -> bool:
+        """Check if git is available."""
+        try:
+            result = subprocess.run(
+                ["git", "--version"],
+                capture_output=True,
+                text=True,
+                cwd=self.repo_path
+            )
+            return result.returncode == 0
+        except FileNotFoundError:
+            return False
+    
+    def _run_git(self, *args: str, check: bool = True) -> subprocess.CompletedProcess:
+        """Run a git command."""
+        cmd = ["git"] + list(args)
+        if self.verbose:
+            logger.debug(f"Running: {' '.join(cmd)}")
+        
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            cwd=self.repo_path
+        )
+        
+        if check and result.returncode != 0:
+            logger.debug(f"Git error: {result.stderr}")
+        
+        return result
+    
+    @property
+    def is_repo(self) -> bool:
+        """Check if current directory is a git repository."""
+        if not self._git_available:
+            return False
+        result = self._run_git("rev-parse", "--git-dir", check=False)
+        return result.returncode == 0
+    
+    def get_status(self) -> GitStatus:
+        """Get repository status."""
+        status = GitStatus()
+        
+        if not self.is_repo:
+            return status
+        
+        # Get branch
+        result = self._run_git("branch", "--show-current", check=False)
+        if result.returncode == 0:
+            status.branch = result.stdout.strip()
+        
+        # Get status
+        result = self._run_git("status", "--porcelain", check=False)
+        if result.returncode == 0:
+            for line in result.stdout.strip().split("\n"):
+                if not line:
+                    continue
+                
+                status_code = line[:2]
+                file_path = line[3:]
+                
+                if status_code[0] in "MADRCU":
+                    status.staged_files.append(file_path)
+                if status_code[1] in "MD":
+                    status.modified_files.append(file_path)
+                if status_code == "??":
+                    status.untracked_files.append(file_path)
+        
+        status.is_clean = not status.has_changes
+        
+        # Get ahead/behind
+        result = self._run_git("rev-list", "--left-right", "--count", "HEAD...@{u}", check=False)
+        if result.returncode == 0:
+            parts = result.stdout.strip().split()
+            if len(parts) == 2:
+                status.ahead = int(parts[0])
+                status.behind = int(parts[1])
+        
+        return status
+    
+    def get_diff(self, staged: bool = False, file_path: Optional[str] = None) -> List[GitDiff]:
+        """Get diff information."""
+        diffs = []
+        
+        if not self.is_repo:
+            return diffs
+        
+        args = ["diff"]
+        if staged:
+            args.append("--staged")
+        args.append("--numstat")
+        
+        if file_path:
+            args.append("--")
+            args.append(file_path)
+        
+        result = self._run_git(*args, check=False)
+        if result.returncode != 0:
+            return diffs
+        
+        for line in result.stdout.strip().split("\n"):
+            if not line:
+                continue
+            
+            parts = line.split("\t")
+            if len(parts) >= 3:
+                additions = int(parts[0]) if parts[0] != "-" else 0
+                deletions = int(parts[1]) if parts[1] != "-" else 0
+                path = parts[2]
+                
+                diffs.append(GitDiff(
+                    file_path=path,
+                    additions=additions,
+                    deletions=deletions
+                ))
+        
+        return diffs
+    
+    def get_diff_content(self, staged: bool = False, file_path: Optional[str] = None) -> str:
+        """Get full diff content."""
+        if not self.is_repo:
+            return ""
+        
+        args = ["diff"]
+        if staged:
+            args.append("--staged")
+        
+        if file_path:
+            args.append("--")
+            args.append(file_path)
+        
+        result = self._run_git(*args, check=False)
+        return result.stdout if result.returncode == 0 else ""
+    
+    def stage_files(self, files: Optional[List[str]] = None) -> bool:
+        """Stage files for commit."""
+        if not self.is_repo:
+            return False
+        
+        if files:
+            result = self._run_git("add", *files, check=False)
+        else:
+            result = self._run_git("add", "-A", check=False)
+        
+        return result.returncode == 0
+    
+    def commit(self, message: str, allow_empty: bool = False) -> Optional[GitCommit]:
+        """Create a commit."""
+        if not self.is_repo:
+            return None
+        
+        args = ["commit", "-m", message]
+        if allow_empty:
+            args.append("--allow-empty")
+        
+        result = self._run_git(*args, check=False)
+        
+        if result.returncode != 0:
+            logger.debug(f"Commit failed: {result.stderr}")
+            return None
+        
+        # Get commit info
+        return self.get_last_commit()
+    
+    def get_last_commit(self) -> Optional[GitCommit]:
+        """Get the last commit."""
+        if not self.is_repo:
+            return None
+        
+        result = self._run_git(
+            "log", "-1",
+            "--format=%H|%h|%s|%an|%ai",
+            check=False
+        )
+        
+        if result.returncode != 0:
+            return None
+        
+        parts = result.stdout.strip().split("|")
+        if len(parts) >= 5:
+            return GitCommit(
+                hash=parts[0],
+                short_hash=parts[1],
+                message=parts[2],
+                author=parts[3],
+                date=parts[4]
+            )
+        
+        return None
+    
+    def get_log(self, count: int = 10) -> List[GitCommit]:
+        """Get commit log."""
+        commits = []
+        
+        if not self.is_repo:
+            return commits
+        
+        result = self._run_git(
+            "log", f"-{count}",
+            "--format=%H|%h|%s|%an|%ai",
+            check=False
+        )
+        
+        if result.returncode != 0:
+            return commits
+        
+        for line in result.stdout.strip().split("\n"):
+            if not line:
+                continue
+            
+            parts = line.split("|")
+            if len(parts) >= 5:
+                commits.append(GitCommit(
+                    hash=parts[0],
+                    short_hash=parts[1],
+                    message=parts[2],
+                    author=parts[3],
+                    date=parts[4]
+                ))
+        
+        return commits
+    
+    def undo_last_commit(self, soft: bool = True) -> bool:
+        """Undo the last commit."""
+        if not self.is_repo:
+            return False
+        
+        reset_type = "--soft" if soft else "--hard"
+        result = self._run_git("reset", reset_type, "HEAD~1", check=False)
+        
+        return result.returncode == 0
+    
+    def create_branch(self, name: str, checkout: bool = True) -> bool:
+        """Create a new branch."""
+        if not self.is_repo:
+            return False
+        
+        if checkout:
+            result = self._run_git("checkout", "-b", name, check=False)
+        else:
+            result = self._run_git("branch", name, check=False)
+        
+        return result.returncode == 0
+    
+    def checkout_branch(self, name: str) -> bool:
+        """Checkout a branch."""
+        if not self.is_repo:
+            return False
+        
+        result = self._run_git("checkout", name, check=False)
+        return result.returncode == 0
+    
+    def get_branches(self) -> List[str]:
+        """Get list of branches."""
+        if not self.is_repo:
+            return []
+        
+        result = self._run_git("branch", "--list", check=False)
+        if result.returncode != 0:
+            return []
+        
+        branches = []
+        for line in result.stdout.strip().split("\n"):
+            if line:
+                # Remove * and whitespace
+                branch = line.strip().lstrip("* ")
+                branches.append(branch)
+        
+        return branches
+    
+    def stash(self, message: Optional[str] = None) -> bool:
+        """Stash changes."""
+        if not self.is_repo:
+            return False
+        
+        args = ["stash", "push"]
+        if message:
+            args.extend(["-m", message])
+        
+        result = self._run_git(*args, check=False)
+        return result.returncode == 0
+    
+    def stash_pop(self) -> bool:
+        """Pop stashed changes."""
+        if not self.is_repo:
+            return False
+        
+        result = self._run_git("stash", "pop", check=False)
+        return result.returncode == 0
+
+
+# ============================================================================
+# Commit Message Generator
+# ============================================================================
+
+class CommitMessageGenerator:
+    """
+    Generates commit messages using AI or templates.
+    """
+    
+    def __init__(self, use_ai: bool = True):
+        self.use_ai = use_ai
+    
+    def generate(
+        self,
+        diff_content: str,
+        context: Optional[str] = None,
+        style: str = "conventional"
+    ) -> str:
+        """
+        Generate a commit message.
+        
+        Args:
+            diff_content: The diff to describe
+            context: Optional context about the changes
+            style: Message style (conventional, simple, detailed)
+            
+        Returns:
+            Generated commit message
+        """
+        if not diff_content:
+            return "Empty commit"
+        
+        if self.use_ai:
+            return self._generate_with_ai(diff_content, context, style)
+        else:
+            return self._generate_from_diff(diff_content, style)
+    
+    def _generate_with_ai(
+        self,
+        diff_content: str,
+        context: Optional[str],
+        style: str
+    ) -> str:
+        """Generate commit message using AI."""
+        # This would integrate with the agent system
+        # For now, return a template-based message
+        return self._generate_from_diff(diff_content, style)
+    
+    def _generate_from_diff(self, diff_content: str, style: str) -> str:
+        """Generate commit message from diff analysis."""
+        # Analyze diff
+        files_changed = set()
+        additions = 0
+        deletions = 0
+        
+        for line in diff_content.split("\n"):
+            if line.startswith("diff --git"):
+                match = re.search(r"b/(.+)$", line)
+                if match:
+                    files_changed.add(match.group(1))
+            elif line.startswith("+") and not line.startswith("+++"):
+                additions += 1
+            elif line.startswith("-") and not line.startswith("---"):
+                deletions += 1
+        
+        # Determine change type
+        if additions > deletions * 2:
+            change_type = "feat"
+            action = "Add"
+        elif deletions > additions * 2:
+            change_type = "refactor"
+            action = "Remove"
+        else:
+            change_type = "fix"
+            action = "Update"
+        
+        # Build message
+        if len(files_changed) == 1:
+            file_name = list(files_changed)[0]
+            scope = Path(file_name).stem
+            message = f"{change_type}({scope}): {action} {file_name}"
+        elif len(files_changed) <= 3:
+            files_str = ", ".join(sorted(files_changed))
+            message = f"{change_type}: {action} {files_str}"
+        else:
+            message = f"{change_type}: {action} {len(files_changed)} files"
+        
+        if style == "detailed":
+            message += f"\n\n+{additions} -{deletions} lines"
+        
+        return message
+
+
+# ============================================================================
+# Diff Viewer
+# ============================================================================
+
+class DiffViewer:
+    """
+    Rich-based diff viewer.
+    """
+    
+    def __init__(self):
+        self._console = None
+    
+    @property
+    def console(self):
+        """Lazy load Rich console."""
+        if self._console is None:
+            try:
+                from rich.console import Console
+                self._console = Console()
+            except ImportError:
+                self._console = None
+        return self._console
+    
+    def display_diff(self, diff_content: str, title: str = "Changes") -> None:
+        """Display diff with syntax highlighting."""
+        if not self.console:
+            print(diff_content)
+            return
+        
+        from rich.panel import Panel
+        from rich.syntax import Syntax
+        
+        syntax = Syntax(diff_content, "diff", theme="monokai", line_numbers=True)
+        self.console.print(Panel(syntax, title=title, border_style="blue"))
+    
+    def display_status(self, status: GitStatus) -> None:
+        """Display git status."""
+        if not self.console:
+            print(f"Branch: {status.branch}")
+            print(f"Staged: {len(status.staged_files)}")
+            print(f"Modified: {len(status.modified_files)}")
+            print(f"Untracked: {len(status.untracked_files)}")
+            return
+        
+        from rich.panel import Panel
+        from rich.table import Table
+        
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Category")
+        table.add_column("Files", justify="right")
+        
+        table.add_row("Branch", status.branch or "detached")
+        table.add_row("Staged", str(len(status.staged_files)))
+        table.add_row("Modified", str(len(status.modified_files)))
+        table.add_row("Untracked", str(len(status.untracked_files)))
+        
+        if status.ahead or status.behind:
+            table.add_row("Ahead/Behind", f"+{status.ahead} / -{status.behind}")
+        
+        self.console.print(Panel(table, title="📊 Git Status", border_style="green"))
+    
+    def display_log(self, commits: List[GitCommit]) -> None:
+        """Display commit log."""
+        if not self.console:
+            for commit in commits:
+                print(f"{commit.short_hash} {commit.message}")
+            return
+        
+        from rich.table import Table
+        
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Hash")
+        table.add_column("Message")
+        table.add_column("Author")
+        table.add_column("Date")
+        
+        for commit in commits:
+            table.add_row(
+                commit.short_hash,
+                commit.message[:50] + "..." if len(commit.message) > 50 else commit.message,
+                commit.author,
+                commit.date[:10]
+            )
+        
+        self.console.print(table)
+
+
+# ============================================================================
+# CLI Integration Handler
+# ============================================================================
+
+class GitIntegrationHandler:
+    """
+    Handler for integrating Git with PraisonAI CLI.
+    """
+    
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self._git: Optional[GitManager] = None
+        self._viewer: Optional[DiffViewer] = None
+        self._generator: Optional[CommitMessageGenerator] = None
+    
+    @property
+    def feature_name(self) -> str:
+        return "git_integration"
+    
+    def initialize(self, repo_path: Optional[str] = None) -> GitManager:
+        """Initialize Git manager."""
+        self._git = GitManager(repo_path=repo_path, verbose=self.verbose)
+        self._viewer = DiffViewer()
+        self._generator = CommitMessageGenerator()
+        
+        if self.verbose and self._git.is_repo:
+            from rich import print as rprint
+            status = self._git.get_status()
+            rprint(f"[cyan]Git initialized on branch: {status.branch}[/cyan]")
+        
+        return self._git
+    
+    def get_git(self) -> Optional[GitManager]:
+        """Get the Git manager."""
+        return self._git
+    
+    def show_status(self) -> GitStatus:
+        """Show git status."""
+        if not self._git:
+            self._git = self.initialize()
+        
+        status = self._git.get_status()
+        if self._viewer:
+            self._viewer.display_status(status)
+        
+        return status
+    
+    def show_diff(self, staged: bool = False) -> str:
+        """Show diff."""
+        if not self._git:
+            self._git = self.initialize()
+        
+        diff_content = self._git.get_diff_content(staged=staged)
+        if self._viewer and diff_content:
+            self._viewer.display_diff(diff_content)
+        
+        return diff_content
+    
+    def commit(
+        self,
+        message: Optional[str] = None,
+        auto_stage: bool = True
+    ) -> Optional[GitCommit]:
+        """Create a commit."""
+        if not self._git:
+            self._git = self.initialize()
+        
+        if auto_stage:
+            self._git.stage_files()
+        
+        if not message:
+            # Generate message from diff
+            diff_content = self._git.get_diff_content(staged=True)
+            if self._generator:
+                message = self._generator.generate(diff_content)
+            else:
+                message = "Update files"
+        
+        return self._git.commit(message)
+    
+    def undo(self, soft: bool = True) -> bool:
+        """Undo last commit."""
+        if not self._git:
+            self._git = self.initialize()
+        
+        return self._git.undo_last_commit(soft=soft)
+    
+    def show_log(self, count: int = 10) -> List[GitCommit]:
+        """Show commit log."""
+        if not self._git:
+            self._git = self.initialize()
+        
+        commits = self._git.get_log(count=count)
+        if self._viewer:
+            self._viewer.display_log(commits)
+        
+        return commits

src/praisonai/praisonai/cli/features/interactive_tui.py

@@ -0,0 +1,603 @@
+"""
+Interactive TUI System for PraisonAI CLI.
+
+Inspired by Aider's interactive mode and prompt_toolkit usage.
+Provides rich interactive terminal experience with completions and history.
+
+Architecture:
+- InteractiveSession: Main interactive session manager
+- CommandCompleter: Auto-completion for commands and files
+- HistoryManager: Persistent command history
+- StatusDisplay: Rich-based status bar and output
+"""
+
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Configuration
+# ============================================================================
+
+@dataclass
+class InteractiveConfig:
+    """Configuration for interactive session."""
+    prompt: str = ">>> "
+    multiline: bool = True
+    history_file: Optional[str] = None
+    max_history: int = 1000
+    enable_completions: bool = True
+    enable_syntax_highlighting: bool = True
+    vi_mode: bool = False
+    auto_suggest: bool = True
+    show_status_bar: bool = True
+    color_scheme: str = "monokai"
+
+
+# ============================================================================
+# Command Completer
+# ============================================================================
+
+class CommandCompleter:
+    """
+    Provides auto-completion for commands, files, and symbols.
+    """
+    
+    def __init__(
+        self,
+        commands: Optional[List[str]] = None,
+        file_patterns: Optional[List[str]] = None
+    ):
+        self.commands = commands or []
+        self.file_patterns = file_patterns or ["*.py", "*.js", "*.ts"]
+        self._file_cache: List[str] = []
+        self._symbol_cache: List[str] = []
+    
+    def add_commands(self, commands: List[str]) -> None:
+        """Add commands to completion list."""
+        self.commands.extend(commands)
+    
+    def add_symbols(self, symbols: List[str]) -> None:
+        """Add symbols to completion list."""
+        self._symbol_cache.extend(symbols)
+    
+    def refresh_files(self, root: Optional[Path] = None) -> None:
+        """Refresh file cache."""
+        root = root or Path.cwd()
+        self._file_cache = []
+        
+        for pattern in self.file_patterns:
+            for file_path in root.rglob(pattern):
+                try:
+                    rel_path = str(file_path.relative_to(root))
+                    if not any(excl in rel_path for excl in ["__pycache__", "node_modules", ".git"]):
+                        self._file_cache.append(rel_path)
+                except ValueError:
+                    pass
+    
+    def get_completions(self, text: str, cursor_pos: int) -> List[str]:
+        """
+        Get completions for the current input.
+        
+        Args:
+            text: Current input text
+            cursor_pos: Cursor position
+            
+        Returns:
+            List of completion suggestions
+        """
+        # Get word before cursor
+        before_cursor = text[:cursor_pos]
+        words = before_cursor.split()
+        current_word = words[-1] if words else ""
+        
+        completions = []
+        
+        # Slash commands
+        if current_word.startswith("/"):
+            cmd_part = current_word[1:].lower()
+            for cmd in self.commands:
+                if cmd.lower().startswith(cmd_part):
+                    completions.append(f"/{cmd}")
+        
+        # @ mentions for files
+        elif current_word.startswith("@"):
+            file_part = current_word[1:].lower()
+            for file_path in self._file_cache:
+                if file_part in file_path.lower():
+                    completions.append(f"@{file_path}")
+        
+        # General completions
+        else:
+            word_lower = current_word.lower()
+            
+            # Check symbols
+            for symbol in self._symbol_cache:
+                if symbol.lower().startswith(word_lower):
+                    completions.append(symbol)
+            
+            # Check files
+            for file_path in self._file_cache:
+                if word_lower in file_path.lower():
+                    completions.append(file_path)
+        
+        return completions[:20]  # Limit results
+    
+    def create_prompt_toolkit_completer(self) -> Any:
+        """Create a prompt_toolkit completer."""
+        try:
+            from prompt_toolkit.completion import Completer, Completion
+            
+            outer_self = self
+            
+            class PTCompleter(Completer):
+                def get_completions(self, document, complete_event):
+                    text = document.text
+                    cursor_pos = document.cursor_position
+                    
+                    for completion in outer_self.get_completions(text, cursor_pos):
+                        # Calculate start position
+                        words = text[:cursor_pos].split()
+                        current_word = words[-1] if words else ""
+                        start_pos = -len(current_word)
+                        
+                        yield Completion(completion, start_position=start_pos)
+            
+            return PTCompleter()
+        except ImportError:
+            return None
+
+
+# ============================================================================
+# History Manager
+# ============================================================================
+
+class HistoryManager:
+    """
+    Manages command history with persistence.
+    """
+    
+    def __init__(
+        self,
+        history_file: Optional[str] = None,
+        max_entries: int = 1000
+    ):
+        self.history_file = Path(history_file) if history_file else None
+        self.max_entries = max_entries
+        self._history: List[str] = []
+        self._position: int = 0
+        
+        if self.history_file:
+            self._load_history()
+    
+    def _load_history(self) -> None:
+        """Load history from file."""
+        if self.history_file and self.history_file.exists():
+            try:
+                with open(self.history_file, 'r', encoding='utf-8') as f:
+                    self._history = [
+                        line.strip() for line in f.readlines()
+                        if line.strip()
+                    ][-self.max_entries:]
+            except Exception as e:
+                logger.debug(f"Could not load history: {e}")
+    
+    def _save_history(self) -> None:
+        """Save history to file."""
+        if self.history_file:
+            try:
+                self.history_file.parent.mkdir(parents=True, exist_ok=True)
+                with open(self.history_file, 'w', encoding='utf-8') as f:
+                    for entry in self._history[-self.max_entries:]:
+                        f.write(entry + "\n")
+            except Exception as e:
+                logger.debug(f"Could not save history: {e}")
+    
+    def add(self, entry: str) -> None:
+        """Add an entry to history."""
+        entry = entry.strip()
+        if entry and (not self._history or self._history[-1] != entry):
+            self._history.append(entry)
+            self._position = len(self._history)
+            self._save_history()
+    
+    def get_previous(self) -> Optional[str]:
+        """Get previous history entry."""
+        if self._position > 0:
+            self._position -= 1
+            return self._history[self._position]
+        return None
+    
+    def get_next(self) -> Optional[str]:
+        """Get next history entry."""
+        if self._position < len(self._history) - 1:
+            self._position += 1
+            return self._history[self._position]
+        elif self._position == len(self._history) - 1:
+            self._position = len(self._history)
+            return ""
+        return None
+    
+    def search(self, prefix: str) -> List[str]:
+        """Search history for entries starting with prefix."""
+        return [
+            entry for entry in self._history
+            if entry.lower().startswith(prefix.lower())
+        ]
+    
+    def get_all(self) -> List[str]:
+        """Get all history entries."""
+        return self._history.copy()
+    
+    def clear(self) -> None:
+        """Clear history."""
+        self._history.clear()
+        self._position = 0
+        if self.history_file and self.history_file.exists():
+            self.history_file.unlink()
+    
+    def create_prompt_toolkit_history(self) -> Any:
+        """Create a prompt_toolkit history object."""
+        try:
+            from prompt_toolkit.history import FileHistory, InMemoryHistory
+            
+            if self.history_file:
+                return FileHistory(str(self.history_file))
+            return InMemoryHistory()
+        except ImportError:
+            return None
+
+
+# ============================================================================
+# Status Display
+# ============================================================================
+
+class StatusDisplay:
+    """
+    Rich-based status display for interactive session.
+    """
+    
+    def __init__(self, show_status_bar: bool = True):
+        self.show_status_bar = show_status_bar
+        self._console = None
+        self._status_items: Dict[str, str] = {}
+    
+    @property
+    def console(self):
+        """Lazy load Rich console."""
+        if self._console is None:
+            try:
+                from rich.console import Console
+                self._console = Console()
+            except ImportError:
+                self._console = None
+        return self._console
+    
+    def set_status(self, key: str, value: str) -> None:
+        """Set a status item."""
+        self._status_items[key] = value
+    
+    def clear_status(self, key: str) -> None:
+        """Clear a status item."""
+        self._status_items.pop(key, None)
+    
+    def print_status_bar(self) -> None:
+        """Print the status bar."""
+        if not self.show_status_bar or not self.console:
+            return
+        
+        from rich.columns import Columns
+        from rich.text import Text
+        
+        items = []
+        for key, value in self._status_items.items():
+            items.append(Text(f"{key}: {value}", style="dim"))
+        
+        if items:
+            self.console.print(Columns(items, equal=True, expand=True))
+    
+    def print_welcome(self, version: str = "1.0.0") -> None:
+        """Print welcome message."""
+        if not self.console:
+            print(f"PraisonAI CLI v{version}")
+            return
+        
+        from rich.panel import Panel
+        from rich.text import Text
+        
+        welcome = Text()
+        welcome.append("PraisonAI CLI", style="bold cyan")
+        welcome.append(f" v{version}\n", style="dim")
+        welcome.append("Type ", style="dim")
+        welcome.append("/help", style="bold green")
+        welcome.append(" for commands, ", style="dim")
+        welcome.append("/exit", style="bold yellow")
+        welcome.append(" to quit", style="dim")
+        
+        self.console.print(Panel(welcome, border_style="blue"))
+    
+    def print_response(self, response: str, title: str = "Response") -> None:
+        """Print a response with formatting."""
+        if not self.console:
+            print(response)
+            return
+        
+        from rich.panel import Panel
+        from rich.markdown import Markdown
+        
+        try:
+            md = Markdown(response)
+            self.console.print(Panel(md, title=title, border_style="green"))
+        except Exception:
+            self.console.print(Panel(response, title=title, border_style="green"))
+    
+    def print_error(self, error: str) -> None:
+        """Print an error message."""
+        if not self.console:
+            print(f"Error: {error}")
+            return
+        
+        from rich.panel import Panel
+        self.console.print(Panel(error, title="Error", border_style="red"))
+    
+    def print_info(self, message: str) -> None:
+        """Print an info message."""
+        if not self.console:
+            print(message)
+            return
+        
+        self.console.print(f"[cyan]ℹ[/cyan] {message}")
+    
+    def print_success(self, message: str) -> None:
+        """Print a success message."""
+        if not self.console:
+            print(message)
+            return
+        
+        self.console.print(f"[green]✓[/green] {message}")
+
+
+# ============================================================================
+# Interactive Session
+# ============================================================================
+
+class InteractiveSession:
+    """
+    Main interactive session manager.
+    
+    Provides a rich interactive terminal experience with:
+    - Command completion
+    - History
+    - Syntax highlighting
+    - Status bar
+    - Keyboard shortcuts
+    """
+    
+    def __init__(
+        self,
+        config: Optional[InteractiveConfig] = None,
+        on_input: Optional[Callable[[str], Optional[str]]] = None,
+        on_command: Optional[Callable[[str], Optional[Dict[str, Any]]]] = None
+    ):
+        self.config = config or InteractiveConfig()
+        self.on_input = on_input
+        self.on_command = on_command
+        
+        self.completer = CommandCompleter()
+        self.history = HistoryManager(
+            history_file=self.config.history_file,
+            max_entries=self.config.max_history
+        )
+        self.display = StatusDisplay(show_status_bar=self.config.show_status_bar)
+        
+        self._running = False
+        self._prompt_session = None
+    
+    def _create_prompt_session(self) -> Any:
+        """Create a prompt_toolkit session."""
+        try:
+            from prompt_toolkit import PromptSession
+            from prompt_toolkit.lexers import PygmentsLexer
+            from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+            from pygments.lexers import MarkdownLexer
+            
+            session_kwargs = {
+                "message": self.config.prompt,
+                "multiline": self.config.multiline,
+            }
+            
+            # Add completer
+            if self.config.enable_completions:
+                completer = self.completer.create_prompt_toolkit_completer()
+                if completer:
+                    session_kwargs["completer"] = completer
+            
+            # Add history
+            history = self.history.create_prompt_toolkit_history()
+            if history:
+                session_kwargs["history"] = history
+            
+            # Add syntax highlighting
+            if self.config.enable_syntax_highlighting:
+                session_kwargs["lexer"] = PygmentsLexer(MarkdownLexer)
+            
+            # Add auto-suggest
+            if self.config.auto_suggest:
+                session_kwargs["auto_suggest"] = AutoSuggestFromHistory()
+            
+            # VI mode
+            if self.config.vi_mode:
+                from prompt_toolkit.enums import EditingMode
+                session_kwargs["editing_mode"] = EditingMode.VI
+            
+            return PromptSession(**session_kwargs)
+        
+        except ImportError as e:
+            logger.debug(f"prompt_toolkit not available: {e}")
+            return None
+    
+    def _get_input_fallback(self) -> str:
+        """Fallback input method without prompt_toolkit."""
+        try:
+            if self.config.multiline:
+                print(f"{self.config.prompt}(Enter empty line to submit)")
+                lines = []
+                while True:
+                    line = input()
+                    if not line:
+                        break
+                    lines.append(line)
+                return "\n".join(lines)
+            else:
+                return input(self.config.prompt)
+        except EOFError:
+            return "/exit"
+        except KeyboardInterrupt:
+            print()
+            return ""
+    
+    def get_input(self) -> str:
+        """Get input from user."""
+        if self._prompt_session:
+            try:
+                return self._prompt_session.prompt()
+            except KeyboardInterrupt:
+                return ""
+            except EOFError:
+                return "/exit"
+        else:
+            return self._get_input_fallback()
+    
+    def process_input(self, user_input: str) -> Optional[str]:
+        """
+        Process user input.
+        
+        Args:
+            user_input: Raw user input
+            
+        Returns:
+            Response string or None
+        """
+        user_input = user_input.strip()
+        
+        if not user_input:
+            return None
+        
+        # Add to history
+        self.history.add(user_input)
+        
+        # Check for slash commands
+        if user_input.startswith("/"):
+            if self.on_command:
+                result = self.on_command(user_input)
+                if result:
+                    if result.get("type") == "exit":
+                        self._running = False
+                        return None
+                    return result.get("message")
+            return None
+        
+        # Regular input
+        if self.on_input:
+            return self.on_input(user_input)
+        
+        return None
+    
+    def run(self) -> None:
+        """Run the interactive session."""
+        self._running = True
+        self._prompt_session = self._create_prompt_session()
+        
+        # Print welcome
+        self.display.print_welcome()
+        
+        while self._running:
+            try:
+                # Get input
+                user_input = self.get_input()
+                
+                # Process
+                response = self.process_input(user_input)
+                
+                # Display response
+                if response:
+                    self.display.print_response(response)
+                
+            except KeyboardInterrupt:
+                self.display.print_info("Use /exit to quit")
+            except Exception as e:
+                self.display.print_error(str(e))
+                logger.exception("Error in interactive session")
+    
+    def stop(self) -> None:
+        """Stop the interactive session."""
+        self._running = False
+    
+    def add_commands(self, commands: List[str]) -> None:
+        """Add commands for completion."""
+        self.completer.add_commands(commands)
+    
+    def add_symbols(self, symbols: List[str]) -> None:
+        """Add symbols for completion."""
+        self.completer.add_symbols(symbols)
+    
+    def refresh_files(self, root: Optional[Path] = None) -> None:
+        """Refresh file completions."""
+        self.completer.refresh_files(root)
+
+
+# ============================================================================
+# CLI Integration Handler
+# ============================================================================
+
+class InteractiveTUIHandler:
+    """
+    Handler for integrating Interactive TUI with PraisonAI CLI.
+    """
+    
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self._session: Optional[InteractiveSession] = None
+    
+    @property
+    def feature_name(self) -> str:
+        return "interactive_tui"
+    
+    def initialize(
+        self,
+        config: Optional[InteractiveConfig] = None,
+        on_input: Optional[Callable[[str], Optional[str]]] = None,
+        on_command: Optional[Callable[[str], Optional[Dict[str, Any]]]] = None
+    ) -> InteractiveSession:
+        """Initialize the interactive session."""
+        self._session = InteractiveSession(
+            config=config,
+            on_input=on_input,
+            on_command=on_command
+        )
+        
+        if self.verbose:
+            from rich import print as rprint
+            rprint("[cyan]Interactive TUI initialized[/cyan]")
+        
+        return self._session
+    
+    def get_session(self) -> Optional[InteractiveSession]:
+        """Get the current session."""
+        return self._session
+    
+    def run(self) -> None:
+        """Run the interactive session."""
+        if not self._session:
+            self._session = self.initialize()
+        
+        self._session.run()
+    
+    def stop(self) -> None:
+        """Stop the interactive session."""
+        if self._session:
+            self._session.stop()

src/praisonai/praisonai/cli/features/message_queue.py

@@ -0,0 +1,587 @@
+"""
+Message Queue for Interactive Mode.
+
+Provides FIFO message queuing while the AI agent is processing,
+inspired by Claude Code, Windsurf Cascade, Cursor, and Gemini CLI.
+
+Features:
+- Queue messages while agent is processing
+- Auto-process queue when agent becomes idle
+- Visual indicators for queue status
+- Thread-safe operations
+"""
+
+import threading
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Callable, List, Optional
+
+
+# ============================================================================
+# Enums
+# ============================================================================
+
+class ProcessingState(Enum):
+    """State of the agent processing."""
+    IDLE = "idle"
+    PROCESSING = "processing"
+    WAITING_APPROVAL = "waiting_approval"
+
+
+class MessagePriority(Enum):
+    """Priority levels for queued messages."""
+    LOW = "low"
+    NORMAL = "normal"
+    HIGH = "high"
+
+
+# ============================================================================
+# Data Classes
+# ============================================================================
+
+@dataclass
+class QueuedMessage:
+    """A message in the queue with metadata."""
+    content: str
+    timestamp: float = field(default_factory=time.time)
+    priority: MessagePriority = MessagePriority.NORMAL
+
+
+# ============================================================================
+# MessageQueue - Thread-safe FIFO queue
+# ============================================================================
+
+class MessageQueue:
+    """
+    Thread-safe FIFO message queue.
+    
+    Provides basic queue operations with thread safety for concurrent access.
+    """
+    
+    def __init__(self):
+        self._messages: List[str] = []
+        self._lock = threading.Lock()
+    
+    @property
+    def is_empty(self) -> bool:
+        """Check if queue is empty."""
+        with self._lock:
+            return len(self._messages) == 0
+    
+    @property
+    def count(self) -> int:
+        """Get number of messages in queue."""
+        with self._lock:
+            return len(self._messages)
+    
+    def add(self, message: str) -> bool:
+        """
+        Add a message to the end of the queue.
+        
+        Args:
+            message: The message to add
+            
+        Returns:
+            True if message was added, False if empty/whitespace
+        """
+        trimmed = message.strip() if message else ""
+        if not trimmed:
+            return False
+        
+        with self._lock:
+            self._messages.append(trimmed)
+        return True
+    
+    def pop(self) -> Optional[str]:
+        """
+        Remove and return the first message (FIFO).
+        
+        Returns:
+            The first message, or None if queue is empty
+        """
+        with self._lock:
+            if self._messages:
+                return self._messages.pop(0)
+            return None
+    
+    def peek(self) -> Optional[str]:
+        """
+        View the first message without removing it.
+        
+        Returns:
+            The first message, or None if queue is empty
+        """
+        with self._lock:
+            if self._messages:
+                return self._messages[0]
+            return None
+    
+    def clear(self) -> None:
+        """Remove all messages from the queue."""
+        with self._lock:
+            self._messages.clear()
+    
+    def get_all(self) -> List[str]:
+        """
+        Get all messages as a list (does not remove them).
+        
+        Returns:
+            Copy of all messages in queue order
+        """
+        with self._lock:
+            return self._messages.copy()
+    
+    def remove_at(self, index: int) -> Optional[str]:
+        """
+        Remove message at specific index.
+        
+        Args:
+            index: The index to remove (0-based)
+            
+        Returns:
+            The removed message, or None if index is invalid
+        """
+        with self._lock:
+            if 0 <= index < len(self._messages):
+                return self._messages.pop(index)
+            return None
+
+
+# ============================================================================
+# StateManager - Processing state management
+# ============================================================================
+
+class StateManager:
+    """
+    Manages the processing state with optional callbacks.
+    
+    Tracks whether the agent is idle, processing, or waiting for approval.
+    """
+    
+    def __init__(self, on_state_change: Optional[Callable[[ProcessingState, ProcessingState], None]] = None):
+        self._state = ProcessingState.IDLE
+        self._lock = threading.Lock()
+        self._on_state_change = on_state_change
+    
+    @property
+    def current_state(self) -> ProcessingState:
+        """Get current processing state."""
+        with self._lock:
+            return self._state
+    
+    @property
+    def is_idle(self) -> bool:
+        """Check if currently idle."""
+        return self.current_state == ProcessingState.IDLE
+    
+    @property
+    def is_processing(self) -> bool:
+        """Check if currently processing."""
+        return self.current_state == ProcessingState.PROCESSING
+    
+    def set_state(self, new_state: ProcessingState) -> None:
+        """
+        Set the processing state.
+        
+        Args:
+            new_state: The new state to set
+        """
+        with self._lock:
+            old_state = self._state
+            self._state = new_state
+        
+        # Call callback outside lock to prevent deadlock
+        if self._on_state_change and old_state != new_state:
+            self._on_state_change(old_state, new_state)
+
+
+# ============================================================================
+# QueueDisplay - Visual formatting
+# ============================================================================
+
+class QueueDisplay:
+    """
+    Formats queue and status for display.
+    
+    Provides visual indicators for queue status, inspired by Codex CLI.
+    """
+    
+    def __init__(
+        self,
+        queue: MessageQueue,
+        state_manager: Optional[StateManager] = None,
+        max_message_length: int = 50
+    ):
+        self._queue = queue
+        self._state_manager = state_manager
+        self._max_length = max_message_length
+    
+    def format_queue(self) -> str:
+        """
+        Format queued messages for display.
+        
+        Returns:
+            Formatted string with queued messages
+        """
+        messages = self._queue.get_all()
+        if not messages:
+            return ""
+        
+        lines = []
+        for msg in messages:
+            # Truncate long messages
+            display_msg = msg
+            if len(msg) > self._max_length:
+                display_msg = msg[:self._max_length - 3] + "..."
+            lines.append(f"  ↳ {display_msg}")
+        
+        return "\n".join(lines)
+    
+    def format_status(self) -> str:
+        """
+        Format current processing status.
+        
+        Returns:
+            Status string (e.g., "⏳ Processing..." or "")
+        """
+        if not self._state_manager:
+            return ""
+        
+        state = self._state_manager.current_state
+        if state == ProcessingState.PROCESSING:
+            return "⏳ Processing..."
+        elif state == ProcessingState.WAITING_APPROVAL:
+            return "🔒 Waiting for approval..."
+        return ""
+    
+    def format_queue_count(self) -> str:
+        """
+        Format queue count indicator.
+        
+        Returns:
+            Count string (e.g., "📋 Queued (2)")
+        """
+        count = self._queue.count
+        if count == 0:
+            return ""
+        return f"📋 Queued ({count})"
+
+
+# ============================================================================
+# MessageQueueHandler - Main handler class
+# ============================================================================
+
+class MessageQueueHandler:
+    """
+    Main handler for message queue functionality.
+    
+    Coordinates queue, state, and processing.
+    """
+    
+    def __init__(
+        self,
+        processor: Optional[Callable[[str], str]] = None,
+        on_response: Optional[Callable[[str], None]] = None
+    ):
+        self._processor = processor
+        self._on_response = on_response
+        self._queue = MessageQueue()
+        self._state_manager = StateManager(on_state_change=self._on_state_change)
+        self._processing_lock = threading.Lock()
+    
+    @property
+    def queue(self) -> MessageQueue:
+        """Get the message queue."""
+        return self._queue
+    
+    @property
+    def state_manager(self) -> StateManager:
+        """Get the state manager."""
+        return self._state_manager
+    
+    def submit(self, message: str) -> bool:
+        """
+        Submit a message for processing.
+        
+        If idle, processes immediately. If processing, queues the message.
+        
+        Args:
+            message: The message to submit
+            
+        Returns:
+            True if processed/queued, False if empty message
+        """
+        trimmed = message.strip() if message else ""
+        if not trimmed:
+            return False
+        
+        if self._state_manager.is_idle:
+            # Process immediately
+            self._process_message(trimmed)
+        else:
+            # Queue for later
+            self._queue.add(trimmed)
+        
+        return True
+    
+    def on_processing_complete(self) -> None:
+        """
+        Called when current processing completes.
+        
+        Sets state to idle and processes next queued message if any.
+        """
+        self._state_manager.set_state(ProcessingState.IDLE)
+        self._process_next_in_queue()
+    
+    def get_status(self) -> dict:
+        """
+        Get current status.
+        
+        Returns:
+            Dict with queue_count and state
+        """
+        return {
+            'queue_count': self._queue.count,
+            'state': self._state_manager.current_state.value,
+            'messages': self._queue.get_all()
+        }
+    
+    def clear_queue(self) -> None:
+        """Clear all queued messages."""
+        self._queue.clear()
+    
+    def _process_message(self, message: str) -> None:
+        """Process a single message."""
+        if not self._processor:
+            return
+        
+        with self._processing_lock:
+            self._state_manager.set_state(ProcessingState.PROCESSING)
+            try:
+                response = self._processor(message)
+                if self._on_response and response:
+                    self._on_response(response)
+            finally:
+                self._state_manager.set_state(ProcessingState.IDLE)
+    
+    def _process_next_in_queue(self) -> None:
+        """Process the next message in queue if any."""
+        next_msg = self._queue.pop()
+        if next_msg:
+            self._process_message(next_msg)
+    
+    def _on_state_change(self, old_state: ProcessingState, new_state: ProcessingState) -> None:
+        """Handle state changes."""
+        # Auto-process queue when becoming idle
+        if new_state == ProcessingState.IDLE and old_state == ProcessingState.PROCESSING:
+            # Don't auto-process here to avoid recursion
+            # The on_processing_complete method handles this
+            pass
+
+
+# ============================================================================
+# AsyncProcessor - Background processing
+# ============================================================================
+
+class AsyncProcessor:
+    """
+    Runs work functions in background threads.
+    
+    Allows agent processing to happen asynchronously while
+    the main thread remains responsive for user input.
+    """
+    
+    def __init__(
+        self,
+        on_complete: Optional[Callable[[str], None]] = None,
+        on_status: Optional[Callable[[str], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None
+    ):
+        self._on_complete = on_complete
+        self._on_status = on_status
+        self._on_error = on_error
+        self._thread: Optional[threading.Thread] = None
+        self._running = False
+        self._lock = threading.Lock()
+    
+    @property
+    def is_running(self) -> bool:
+        """Check if currently processing."""
+        with self._lock:
+            return self._running
+    
+    def start(self, work_fn: Callable[[], str]) -> None:
+        """
+        Start processing work in background thread.
+        
+        Args:
+            work_fn: Function to execute (should return result string)
+        """
+        def _worker():
+            try:
+                with self._lock:
+                    self._running = True
+                
+                result = work_fn()
+                
+                with self._lock:
+                    self._running = False
+                
+                if self._on_complete:
+                    self._on_complete(result)
+            except Exception as e:
+                with self._lock:
+                    self._running = False
+                if self._on_error:
+                    self._on_error(e)
+        
+        self._thread = threading.Thread(target=_worker, daemon=True)
+        self._thread.start()
+    
+    def update_status(self, status: str) -> None:
+        """Update status (can be called from work function)."""
+        if self._on_status:
+            self._on_status(status)
+
+
+# ============================================================================
+# LiveStatusDisplay - Real-time status display
+# ============================================================================
+
+class LiveStatusDisplay:
+    """
+    Tracks and displays real-time status during processing.
+    
+    Shows tool calls, command executions, and current status.
+    """
+    
+    def __init__(self):
+        self._status = ""
+        self._tool_calls: List[dict] = []
+        self._commands: List[str] = []
+        self._lock = threading.Lock()
+    
+    @property
+    def current_status(self) -> str:
+        """Get current status message."""
+        with self._lock:
+            return self._status
+    
+    @property
+    def tool_calls(self) -> List[dict]:
+        """Get list of tool calls."""
+        with self._lock:
+            return self._tool_calls.copy()
+    
+    @property
+    def commands(self) -> List[str]:
+        """Get list of commands executed."""
+        with self._lock:
+            return self._commands.copy()
+    
+    def update_status(self, status: str) -> None:
+        """Update current status message."""
+        with self._lock:
+            self._status = status
+    
+    def add_tool_call(self, name: str, args: dict) -> None:
+        """Add a tool call to the display."""
+        with self._lock:
+            self._tool_calls.append({
+                'name': name,
+                'args': args,
+                'timestamp': time.time()
+            })
+    
+    def add_command(self, command: str) -> None:
+        """Add a command execution to the display."""
+        with self._lock:
+            self._commands.append(command)
+    
+    def format(self) -> str:
+        """Format current status for display."""
+        lines = []
+        
+        with self._lock:
+            if self._status:
+                lines.append(f"⏳ {self._status}")
+            
+            for tool in self._tool_calls[-3:]:  # Show last 3 tools
+                lines.append(f"  🔧 {tool['name']}")
+            
+            for cmd in self._commands[-2:]:  # Show last 2 commands
+                display_cmd = cmd[:40] + "..." if len(cmd) > 40 else cmd
+                lines.append(f"  💻 {display_cmd}")
+        
+        return "\n".join(lines)
+    
+    def clear(self) -> None:
+        """Clear all status."""
+        with self._lock:
+            self._status = ""
+            self._tool_calls.clear()
+            self._commands.clear()
+
+
+# ============================================================================
+# NonBlockingInput - Async input handling
+# ============================================================================
+
+class NonBlockingInput:
+    """
+    Handles user input asynchronously.
+    
+    Allows users to type new messages while processing is ongoing.
+    """
+    
+    def __init__(self):
+        self._queue = MessageQueue()
+    
+    @property
+    def has_pending(self) -> bool:
+        """Check if there are pending inputs."""
+        return not self._queue.is_empty
+    
+    @property
+    def pending_count(self) -> int:
+        """Get number of pending inputs."""
+        return self._queue.count
+    
+    def submit(self, message: str) -> bool:
+        """Submit a new input message."""
+        return self._queue.add(message)
+    
+    def pop(self) -> Optional[str]:
+        """Get next pending input."""
+        return self._queue.pop()
+    
+    def peek(self) -> Optional[str]:
+        """View next pending input without removing."""
+        return self._queue.peek()
+    
+    def get_all(self) -> List[str]:
+        """Get all pending inputs."""
+        return self._queue.get_all()
+    
+    def clear(self) -> None:
+        """Clear all pending inputs."""
+        self._queue.clear()
+
+
+# ============================================================================
+# Exports
+# ============================================================================
+
+__all__ = [
+    'ProcessingState',
+    'MessagePriority',
+    'QueuedMessage',
+    'MessageQueue',
+    'StateManager',
+    'QueueDisplay',
+    'MessageQueueHandler',
+    'AsyncProcessor',
+    'LiveStatusDisplay',
+    'NonBlockingInput',
+]

src/praisonai/praisonai/cli/features/repo_map.py

@@ -0,0 +1,860 @@
+"""
+Repository Map System for PraisonAI CLI.
+
+Inspired by Aider's RepoMap using tree-sitter for code parsing.
+Provides intelligent codebase context for LLM interactions.
+
+Architecture:
+- RepoMap: Main class for building repository maps
+- SymbolExtractor: Extracts symbols using tree-sitter or regex fallback
+- SymbolRanker: Ranks symbols by importance using graph analysis
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Set
+from pathlib import Path
+from collections import defaultdict
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Data Classes
+# ============================================================================
+
+@dataclass
+class Symbol:
+    """
+    Represents a code symbol (class, function, method, variable).
+    """
+    name: str
+    kind: str  # class, function, method, variable, import
+    file_path: str
+    line_number: int
+    signature: str = ""  # Full signature for functions/methods
+    parent: Optional[str] = None  # Parent class for methods
+    references: int = 0  # Number of references in codebase
+    
+    @property
+    def qualified_name(self) -> str:
+        """Get fully qualified name."""
+        if self.parent:
+            return f"{self.parent}.{self.name}"
+        return self.name
+    
+    def __hash__(self):
+        return hash((self.name, self.kind, self.file_path, self.line_number))
+
+
+@dataclass
+class FileMap:
+    """
+    Map of symbols in a single file.
+    """
+    file_path: str
+    symbols: List[Symbol] = field(default_factory=list)
+    imports: List[str] = field(default_factory=list)
+    
+    def add_symbol(self, symbol: Symbol) -> None:
+        """Add a symbol to the file map."""
+        self.symbols.append(symbol)
+    
+    def get_summary(self, max_symbols: int = 10) -> str:
+        """Get a summary of the file's symbols."""
+        lines = [f"{self.file_path}:"]
+        
+        # Sort by importance (references) and take top symbols
+        sorted_symbols = sorted(
+            self.symbols,
+            key=lambda s: (s.references, s.kind == "class"),
+            reverse=True
+        )[:max_symbols]
+        
+        for symbol in sorted_symbols:
+            if symbol.signature:
+                lines.append(f"  {symbol.signature}")
+            else:
+                lines.append(f"  {symbol.kind} {symbol.name}")
+        
+        return "\n".join(lines)
+
+
+@dataclass
+class RepoMapConfig:
+    """Configuration for repository mapping."""
+    max_tokens: int = 1024
+    max_files: int = 50
+    max_symbols_per_file: int = 20
+    include_imports: bool = True
+    include_docstrings: bool = False
+    file_extensions: Set[str] = field(default_factory=lambda: {
+        ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".go", ".rs",
+        ".cpp", ".c", ".h", ".hpp", ".rb", ".php", ".swift", ".kt"
+    })
+    exclude_patterns: Set[str] = field(default_factory=lambda: {
+        "__pycache__", "node_modules", ".git", ".venv", "venv",
+        "build", "dist", ".egg-info", "__init__.py"
+    })
+
+
+# ============================================================================
+# Symbol Extraction
+# ============================================================================
+
+class SymbolExtractor:
+    """
+    Extracts symbols from source code.
+    
+    Uses tree-sitter when available, falls back to regex patterns.
+    """
+    
+    def __init__(self, use_tree_sitter: bool = True):
+        self.use_tree_sitter = use_tree_sitter
+        self._tree_sitter_available = False
+        self._parsers: Dict[str, Any] = {}
+        
+        if use_tree_sitter:
+            self._init_tree_sitter()
+    
+    def _init_tree_sitter(self) -> None:
+        """Initialize tree-sitter if available."""
+        try:
+            # Try to import tree-sitter-languages (pip installable)
+            import tree_sitter_languages
+            self._tree_sitter_available = True
+            self._ts_languages = tree_sitter_languages
+            logger.debug("tree-sitter-languages available")
+        except ImportError:
+            try:
+                # Fallback to tree-sitter with manual language setup
+                import tree_sitter
+                self._tree_sitter_available = True
+                self._tree_sitter = tree_sitter
+                logger.debug("tree-sitter available (manual setup required)")
+            except ImportError:
+                logger.debug("tree-sitter not available, using regex fallback")
+                self._tree_sitter_available = False
+    
+    def extract_symbols(self, file_path: str, content: str) -> List[Symbol]:
+        """
+        Extract symbols from file content.
+        
+        Args:
+            file_path: Path to the file
+            content: File content
+            
+        Returns:
+            List of extracted symbols
+        """
+        ext = Path(file_path).suffix.lower()
+        
+        if self._tree_sitter_available:
+            try:
+                return self._extract_with_tree_sitter(file_path, content, ext)
+            except Exception as e:
+                logger.debug(f"tree-sitter extraction failed: {e}")
+        
+        # Fallback to regex
+        return self._extract_with_regex(file_path, content, ext)
+    
+    def _extract_with_tree_sitter(
+        self, file_path: str, content: str, ext: str
+    ) -> List[Symbol]:
+        """Extract symbols using tree-sitter."""
+        symbols = []
+        
+        # Map extension to language
+        lang_map = {
+            ".py": "python",
+            ".js": "javascript",
+            ".ts": "typescript",
+            ".jsx": "javascript",
+            ".tsx": "typescript",
+            ".java": "java",
+            ".go": "go",
+            ".rs": "rust",
+            ".rb": "ruby",
+            ".cpp": "cpp",
+            ".c": "c",
+            ".h": "c",
+        }
+        
+        lang = lang_map.get(ext)
+        if not lang:
+            return self._extract_with_regex(file_path, content, ext)
+        
+        try:
+            parser = self._ts_languages.get_parser(lang)
+            tree = parser.parse(content.encode())
+            
+            # Extract based on language
+            if lang == "python":
+                symbols = self._extract_python_symbols(file_path, tree, content)
+            else:
+                # Generic extraction for other languages
+                symbols = self._extract_generic_symbols(file_path, tree, content, lang)
+        except Exception as e:
+            logger.debug(f"tree-sitter parsing failed for {lang}: {e}")
+            return self._extract_with_regex(file_path, content, ext)
+        
+        return symbols
+    
+    def _extract_python_symbols(
+        self, file_path: str, tree: Any, content: str
+    ) -> List[Symbol]:
+        """Extract Python symbols from tree-sitter AST."""
+        symbols = []
+        lines = content.split("\n")
+        
+        def visit_node(node, parent_class=None):
+            if node.type == "class_definition":
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    class_name = content[name_node.start_byte:name_node.end_byte]
+                    line_num = node.start_point[0] + 1
+                    
+                    # Get class signature
+                    sig_end = node.children[0].end_byte if node.children else node.start_byte + 50
+                    signature = content[node.start_byte:sig_end].split("\n")[0]
+                    
+                    symbols.append(Symbol(
+                        name=class_name,
+                        kind="class",
+                        file_path=file_path,
+                        line_number=line_num,
+                        signature=signature.strip()
+                    ))
+                    
+                    # Visit children with class context
+                    for child in node.children:
+                        visit_node(child, class_name)
+                    return
+            
+            elif node.type == "function_definition":
+                name_node = node.child_by_field_name("name")
+                if name_node:
+                    func_name = content[name_node.start_byte:name_node.end_byte]
+                    line_num = node.start_point[0] + 1
+                    
+                    # Get function signature
+                    sig_line = lines[line_num - 1] if line_num <= len(lines) else ""
+                    
+                    kind = "method" if parent_class else "function"
+                    symbols.append(Symbol(
+                        name=func_name,
+                        kind=kind,
+                        file_path=file_path,
+                        line_number=line_num,
+                        signature=sig_line.strip(),
+                        parent=parent_class
+                    ))
+            
+            # Visit children
+            for child in node.children:
+                visit_node(child, parent_class)
+        
+        visit_node(tree.root_node)
+        return symbols
+    
+    def _extract_generic_symbols(
+        self, file_path: str, tree: Any, content: str, lang: str
+    ) -> List[Symbol]:
+        """Generic symbol extraction for other languages."""
+        symbols = []
+        
+        # Node types for different languages
+        class_types = {"class_definition", "class_declaration", "struct_definition"}
+        func_types = {"function_definition", "function_declaration", "method_definition"}
+        
+        def visit_node(node, parent=None):
+            if node.type in class_types:
+                name = self._get_node_name(node, content)
+                if name:
+                    symbols.append(Symbol(
+                        name=name,
+                        kind="class",
+                        file_path=file_path,
+                        line_number=node.start_point[0] + 1
+                    ))
+                    for child in node.children:
+                        visit_node(child, name)
+                    return
+            
+            elif node.type in func_types:
+                name = self._get_node_name(node, content)
+                if name:
+                    symbols.append(Symbol(
+                        name=name,
+                        kind="method" if parent else "function",
+                        file_path=file_path,
+                        line_number=node.start_point[0] + 1,
+                        parent=parent
+                    ))
+            
+            for child in node.children:
+                visit_node(child, parent)
+        
+        visit_node(tree.root_node)
+        return symbols
+    
+    def _get_node_name(self, node: Any, content: str) -> Optional[str]:
+        """Get name from a tree-sitter node."""
+        name_node = node.child_by_field_name("name")
+        if name_node:
+            return content[name_node.start_byte:name_node.end_byte]
+        return None
+    
+    def _extract_with_regex(
+        self, file_path: str, content: str, ext: str
+    ) -> List[Symbol]:
+        """Extract symbols using regex patterns (fallback)."""
+        symbols = []
+        lines = content.split("\n")
+        
+        if ext == ".py":
+            symbols = self._extract_python_regex(file_path, lines)
+        elif ext in {".js", ".ts", ".jsx", ".tsx"}:
+            symbols = self._extract_js_regex(file_path, lines)
+        elif ext in {".java", ".kt"}:
+            symbols = self._extract_java_regex(file_path, lines)
+        elif ext == ".go":
+            symbols = self._extract_go_regex(file_path, lines)
+        elif ext == ".rs":
+            symbols = self._extract_rust_regex(file_path, lines)
+        else:
+            # Generic extraction
+            symbols = self._extract_generic_regex(file_path, lines)
+        
+        return symbols
+    
+    def _extract_python_regex(self, file_path: str, lines: List[str]) -> List[Symbol]:
+        """Extract Python symbols using regex."""
+        symbols = []
+        current_class = None
+        
+        class_pattern = re.compile(r'^class\s+(\w+)')
+        func_pattern = re.compile(r'^(\s*)def\s+(\w+)\s*\(([^)]*)\)')
+        
+        for i, line in enumerate(lines):
+            line_num = i + 1
+            
+            # Check for class
+            class_match = class_pattern.match(line)
+            if class_match:
+                current_class = class_match.group(1)
+                symbols.append(Symbol(
+                    name=current_class,
+                    kind="class",
+                    file_path=file_path,
+                    line_number=line_num,
+                    signature=line.strip()
+                ))
+                continue
+            
+            # Check for function/method
+            func_match = func_pattern.match(line)
+            if func_match:
+                indent = len(func_match.group(1))
+                func_name = func_match.group(2)
+                
+                # If indented, it's a method
+                if indent > 0 and current_class:
+                    symbols.append(Symbol(
+                        name=func_name,
+                        kind="method",
+                        file_path=file_path,
+                        line_number=line_num,
+                        signature=line.strip(),
+                        parent=current_class
+                    ))
+                else:
+                    current_class = None  # Reset class context
+                    symbols.append(Symbol(
+                        name=func_name,
+                        kind="function",
+                        file_path=file_path,
+                        line_number=line_num,
+                        signature=line.strip()
+                    ))
+        
+        return symbols
+    
+    def _extract_js_regex(self, file_path: str, lines: List[str]) -> List[Symbol]:
+        """Extract JavaScript/TypeScript symbols using regex."""
+        symbols = []
+        
+        class_pattern = re.compile(r'(?:export\s+)?class\s+(\w+)')
+        func_pattern = re.compile(
+            r'(?:export\s+)?(?:async\s+)?function\s+(\w+)|'
+            r'(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>'
+        )
+        
+        for i, line in enumerate(lines):
+            line_num = i + 1
+            
+            class_match = class_pattern.search(line)
+            if class_match:
+                symbols.append(Symbol(
+                    name=class_match.group(1),
+                    kind="class",
+                    file_path=file_path,
+                    line_number=line_num,
+                    signature=line.strip()[:80]
+                ))
+            
+            func_match = func_pattern.search(line)
+            if func_match:
+                name = func_match.group(1) or func_match.group(2)
+                if name:
+                    symbols.append(Symbol(
+                        name=name,
+                        kind="function",
+                        file_path=file_path,
+                        line_number=line_num,
+                        signature=line.strip()[:80]
+                    ))
+        
+        return symbols
+    
+    def _extract_java_regex(self, file_path: str, lines: List[str]) -> List[Symbol]:
+        """Extract Java/Kotlin symbols using regex."""
+        symbols = []
+        
+        class_pattern = re.compile(
+            r'(?:public|private|protected)?\s*(?:static\s+)?'
+            r'(?:class|interface|enum)\s+(\w+)'
+        )
+        method_pattern = re.compile(
+            r'(?:public|private|protected)?\s*(?:static\s+)?'
+            r'(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\('
+        )
+        
+        for i, line in enumerate(lines):
+            line_num = i + 1
+            
+            class_match = class_pattern.search(line)
+            if class_match:
+                symbols.append(Symbol(
+                    name=class_match.group(1),
+                    kind="class",
+                    file_path=file_path,
+                    line_number=line_num
+                ))
+            
+            method_match = method_pattern.search(line)
+            if method_match and not class_match:
+                symbols.append(Symbol(
+                    name=method_match.group(1),
+                    kind="method",
+                    file_path=file_path,
+                    line_number=line_num
+                ))
+        
+        return symbols
+    
+    def _extract_go_regex(self, file_path: str, lines: List[str]) -> List[Symbol]:
+        """Extract Go symbols using regex."""
+        symbols = []
+        
+        func_pattern = re.compile(r'^func\s+(?:\([^)]+\)\s+)?(\w+)')
+        type_pattern = re.compile(r'^type\s+(\w+)\s+(?:struct|interface)')
+        
+        for i, line in enumerate(lines):
+            line_num = i + 1
+            
+            type_match = type_pattern.match(line)
+            if type_match:
+                symbols.append(Symbol(
+                    name=type_match.group(1),
+                    kind="class",
+                    file_path=file_path,
+                    line_number=line_num
+                ))
+            
+            func_match = func_pattern.match(line)
+            if func_match:
+                symbols.append(Symbol(
+                    name=func_match.group(1),
+                    kind="function",
+                    file_path=file_path,
+                    line_number=line_num
+                ))
+        
+        return symbols
+    
+    def _extract_rust_regex(self, file_path: str, lines: List[str]) -> List[Symbol]:
+        """Extract Rust symbols using regex."""
+        symbols = []
+        
+        fn_pattern = re.compile(r'(?:pub\s+)?(?:async\s+)?fn\s+(\w+)')
+        struct_pattern = re.compile(r'(?:pub\s+)?struct\s+(\w+)')
+        
+        for i, line in enumerate(lines):
+            line_num = i + 1
+            
+            struct_match = struct_pattern.match(line)
+            if struct_match:
+                symbols.append(Symbol(
+                    name=struct_match.group(1),
+                    kind="class",
+                    file_path=file_path,
+                    line_number=line_num
+                ))
+            
+            fn_match = fn_pattern.search(line)
+            if fn_match:
+                symbols.append(Symbol(
+                    name=fn_match.group(1),
+                    kind="function",
+                    file_path=file_path,
+                    line_number=line_num
+                ))
+        
+        return symbols
+    
+    def _extract_generic_regex(self, file_path: str, lines: List[str]) -> List[Symbol]:
+        """Generic symbol extraction for unknown languages."""
+        symbols = []
+        
+        # Very basic patterns
+        class_pattern = re.compile(r'(?:class|struct|interface)\s+(\w+)')
+        func_pattern = re.compile(r'(?:function|def|fn|func)\s+(\w+)')
+        
+        for i, line in enumerate(lines):
+            line_num = i + 1
+            
+            class_match = class_pattern.search(line)
+            if class_match:
+                symbols.append(Symbol(
+                    name=class_match.group(1),
+                    kind="class",
+                    file_path=file_path,
+                    line_number=line_num
+                ))
+            
+            func_match = func_pattern.search(line)
+            if func_match:
+                symbols.append(Symbol(
+                    name=func_match.group(1),
+                    kind="function",
+                    file_path=file_path,
+                    line_number=line_num
+                ))
+        
+        return symbols
+
+
+# ============================================================================
+# Symbol Ranking
+# ============================================================================
+
+class SymbolRanker:
+    """
+    Ranks symbols by importance using reference counting and graph analysis.
+    """
+    
+    def __init__(self):
+        self.symbol_refs: Dict[str, int] = defaultdict(int)
+        self.file_refs: Dict[str, Set[str]] = defaultdict(set)
+    
+    def analyze_references(
+        self, file_maps: Dict[str, FileMap], all_content: Dict[str, str]
+    ) -> None:
+        """
+        Analyze references between symbols across files.
+        
+        Args:
+            file_maps: Map of file path to FileMap
+            all_content: Map of file path to content
+        """
+        # Build symbol name set
+        all_symbols = set()
+        for file_map in file_maps.values():
+            for symbol in file_map.symbols:
+                all_symbols.add(symbol.name)
+        
+        # Count references
+        for file_path, content in all_content.items():
+            for symbol_name in all_symbols:
+                # Simple word boundary match
+                pattern = rf'\b{re.escape(symbol_name)}\b'
+                matches = len(re.findall(pattern, content))
+                if matches > 0:
+                    self.symbol_refs[symbol_name] += matches
+                    self.file_refs[file_path].add(symbol_name)
+        
+        # Update symbol reference counts
+        for file_map in file_maps.values():
+            for symbol in file_map.symbols:
+                symbol.references = self.symbol_refs.get(symbol.name, 0)
+    
+    def get_top_symbols(
+        self, file_maps: Dict[str, FileMap], max_symbols: int = 50
+    ) -> List[Symbol]:
+        """Get the most important symbols across the codebase."""
+        all_symbols = []
+        for file_map in file_maps.values():
+            all_symbols.extend(file_map.symbols)
+        
+        # Sort by references and kind priority
+        kind_priority = {"class": 3, "function": 2, "method": 1, "variable": 0}
+        
+        sorted_symbols = sorted(
+            all_symbols,
+            key=lambda s: (s.references, kind_priority.get(s.kind, 0)),
+            reverse=True
+        )
+        
+        return sorted_symbols[:max_symbols]
+
+
+# ============================================================================
+# Repository Map
+# ============================================================================
+
+class RepoMap:
+    """
+    Main class for building repository maps.
+    
+    Provides intelligent codebase context for LLM interactions.
+    """
+    
+    def __init__(
+        self,
+        root: Optional[str] = None,
+        config: Optional[RepoMapConfig] = None,
+        verbose: bool = False
+    ):
+        self.root = Path(root) if root else Path.cwd()
+        self.config = config or RepoMapConfig()
+        self.verbose = verbose
+        
+        self.extractor = SymbolExtractor()
+        self.ranker = SymbolRanker()
+        
+        self._file_maps: Dict[str, FileMap] = {}
+        self._all_content: Dict[str, str] = {}
+        self._last_map: Optional[str] = None
+    
+    def scan(self, paths: Optional[List[str]] = None) -> None:
+        """
+        Scan the repository for symbols.
+        
+        Args:
+            paths: Optional list of specific paths to scan
+        """
+        if paths:
+            files_to_scan = [Path(p) for p in paths]
+        else:
+            files_to_scan = self._find_files()
+        
+        for file_path in files_to_scan:
+            try:
+                self._scan_file(file_path)
+            except Exception as e:
+                logger.debug(f"Error scanning {file_path}: {e}")
+        
+        # Analyze references
+        self.ranker.analyze_references(self._file_maps, self._all_content)
+        
+        if self.verbose:
+            logger.info(f"Scanned {len(self._file_maps)} files")
+    
+    def _find_files(self) -> List[Path]:
+        """Find all relevant source files in the repository."""
+        files = []
+        
+        for ext in self.config.file_extensions:
+            for file_path in self.root.rglob(f"*{ext}"):
+                # Check exclusions
+                if any(excl in str(file_path) for excl in self.config.exclude_patterns):
+                    continue
+                files.append(file_path)
+        
+        return files[:self.config.max_files]
+    
+    def _scan_file(self, file_path: Path) -> None:
+        """Scan a single file for symbols."""
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="ignore")
+        except Exception as e:
+            logger.debug(f"Could not read {file_path}: {e}")
+            return
+        
+        rel_path = str(file_path.relative_to(self.root))
+        self._all_content[rel_path] = content
+        
+        symbols = self.extractor.extract_symbols(rel_path, content)
+        
+        file_map = FileMap(file_path=rel_path)
+        for symbol in symbols[:self.config.max_symbols_per_file]:
+            file_map.add_symbol(symbol)
+        
+        self._file_maps[rel_path] = file_map
+    
+    def get_map(
+        self,
+        focus_files: Optional[List[str]] = None,
+        max_tokens: Optional[int] = None
+    ) -> str:
+        """
+        Get the repository map as a string.
+        
+        Args:
+            focus_files: Files to prioritize in the map
+            max_tokens: Maximum tokens for the map
+            
+        Returns:
+            Formatted repository map string
+        """
+        if not self._file_maps:
+            self.scan()
+        
+        max_tokens = max_tokens or self.config.max_tokens
+        
+        # Get top symbols
+        top_symbols = self.ranker.get_top_symbols(self._file_maps)
+        
+        # Group by file
+        file_symbols: Dict[str, List[Symbol]] = defaultdict(list)
+        for symbol in top_symbols:
+            file_symbols[symbol.file_path].append(symbol)
+        
+        # Prioritize focus files
+        if focus_files:
+            focus_set = set(focus_files)
+            sorted_files = sorted(
+                file_symbols.keys(),
+                key=lambda f: (f not in focus_set, f)
+            )
+        else:
+            sorted_files = sorted(file_symbols.keys())
+        
+        # Build map
+        lines = []
+        estimated_tokens = 0
+        
+        for file_path in sorted_files:
+            symbols = file_symbols[file_path]
+            
+            file_lines = [f"{file_path}:"]
+            for symbol in symbols:
+                if symbol.signature:
+                    file_lines.append(f"  │{symbol.signature}")
+                else:
+                    file_lines.append(f"  │{symbol.kind} {symbol.name}")
+            file_lines.append("  ⋮...")
+            
+            file_text = "\n".join(file_lines)
+            file_tokens = len(file_text) // 4  # Rough token estimate
+            
+            if estimated_tokens + file_tokens > max_tokens:
+                break
+            
+            lines.extend(file_lines)
+            estimated_tokens += file_tokens
+        
+        self._last_map = "\n".join(lines)
+        return self._last_map
+    
+    def get_file_symbols(self, file_path: str) -> List[Symbol]:
+        """Get symbols for a specific file."""
+        if file_path in self._file_maps:
+            return self._file_maps[file_path].symbols
+        return []
+    
+    def get_symbol_context(self, symbol_name: str) -> Optional[str]:
+        """Get context around a specific symbol."""
+        for file_path, file_map in self._file_maps.items():
+            for symbol in file_map.symbols:
+                if symbol.name == symbol_name:
+                    content = self._all_content.get(file_path, "")
+                    lines = content.split("\n")
+                    
+                    # Get lines around the symbol
+                    start = max(0, symbol.line_number - 3)
+                    end = min(len(lines), symbol.line_number + 10)
+                    
+                    context_lines = lines[start:end]
+                    return f"{file_path}:{symbol.line_number}\n" + "\n".join(context_lines)
+        
+        return None
+    
+    def refresh(self) -> None:
+        """Refresh the repository map."""
+        self._file_maps.clear()
+        self._all_content.clear()
+        self.ranker = SymbolRanker()
+        self.scan()
+
+
+# ============================================================================
+# CLI Integration Handler
+# ============================================================================
+
+class RepoMapHandler:
+    """
+    Handler for integrating RepoMap with PraisonAI CLI.
+    """
+    
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self._repo_map: Optional[RepoMap] = None
+    
+    @property
+    def feature_name(self) -> str:
+        return "repo_map"
+    
+    def initialize(
+        self,
+        root: Optional[str] = None,
+        config: Optional[RepoMapConfig] = None
+    ) -> RepoMap:
+        """Initialize the repository map."""
+        self._repo_map = RepoMap(
+            root=root,
+            config=config,
+            verbose=self.verbose
+        )
+        
+        if self.verbose:
+            from rich import print as rprint
+            rprint(f"[cyan]RepoMap initialized for: {self._repo_map.root}[/cyan]")
+        
+        return self._repo_map
+    
+    def get_map(self, focus_files: Optional[List[str]] = None) -> str:
+        """Get the repository map."""
+        if not self._repo_map:
+            self._repo_map = self.initialize()
+        
+        return self._repo_map.get_map(focus_files=focus_files)
+    
+    def get_context(self, symbol_name: str) -> Optional[str]:
+        """Get context for a symbol."""
+        if not self._repo_map:
+            self._repo_map = self.initialize()
+        
+        return self._repo_map.get_symbol_context(symbol_name)
+    
+    def refresh(self) -> None:
+        """Refresh the map."""
+        if self._repo_map:
+            self._repo_map.refresh()
+    
+    def print_map(self) -> None:
+        """Print the repository map."""
+        from rich.console import Console
+        from rich.panel import Panel
+        from rich.syntax import Syntax
+        
+        console = Console()
+        map_str = self.get_map()
+        
+        console.print(Panel(
+            Syntax(map_str, "text", theme="monokai"),
+            title="📁 Repository Map",
+            border_style="blue"
+        ))

src/praisonai/praisonai/cli/features/router.py

@@ -3,12 +3,45 @@ Router Handler for CLI.
 
 Provides smart model selection based on task complexity.
 Usage: praisonai "Complex task" --router
+
+Supports custom model configuration from agents.yaml/workflow.yaml:
+
+models:
+  gpt-4o-mini:
+    provider: openai
+    complexity: [simple, moderate]
+    cost_per_1k: 0.00075
+    capabilities: [text, function-calling]
 """
 
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, List, Optional, Tuple
+from dataclasses import dataclass
+from enum import IntEnum
 from .base import FlagHandler
 
 
+class TaskComplexity(IntEnum):
+    """Enum for task complexity levels."""
+    SIMPLE = 1
+    MODERATE = 2
+    COMPLEX = 3
+    VERY_COMPLEX = 4
+
+
+@dataclass
+class ModelProfile:
+    """Profile for an LLM model with its characteristics."""
+    name: str
+    provider: str
+    complexity_range: Tuple[TaskComplexity, TaskComplexity]
+    cost_per_1k_tokens: float
+    capabilities: List[str]
+    context_window: int = 128000
+    supports_tools: bool = True
+    supports_streaming: bool = True
+    strengths: Optional[List[str]] = None
+
+
 class RouterHandler(FlagHandler):
     """
     Handler for --router flag.
@@ -20,13 +53,82 @@ class RouterHandler(FlagHandler):
         praisonai "Complex analysis" --router
     """
     
-    # Model tiers for routing
-    MODEL_TIERS = {
-        'simple': ['gpt-4o-mini', 'claude-3-haiku', 'gemini-1.5-flash'],
-        'medium': ['gpt-4o', 'claude-3-sonnet', 'gemini-1.5-pro'],
-        'complex': ['gpt-4-turbo', 'claude-3-opus', 'o1-preview'],
+    # Default model tiers for routing (used when no custom models configured)
+    # Note: Use full model names for API compatibility
+    DEFAULT_MODEL_TIERS = {
+        'simple': ['gpt-4o-mini', 'anthropic/claude-3-haiku-20240307', 'gemini/gemini-1.5-flash'],
+        'medium': ['gpt-4o', 'anthropic/claude-3-5-sonnet-20241022', 'gemini/gemini-1.5-pro'],
+        'complex': ['gpt-4-turbo', 'anthropic/claude-3-opus-20240229', 'o1-preview'],
     }
     
+    # Default model profiles
+    DEFAULT_MODELS: List[ModelProfile] = [
+        ModelProfile(
+            name="gpt-4o-mini",
+            provider="openai",
+            complexity_range=(TaskComplexity.SIMPLE, TaskComplexity.MODERATE),
+            cost_per_1k_tokens=0.00075,
+            capabilities=["text", "function-calling"],
+            context_window=128000
+        ),
+        ModelProfile(
+            name="gpt-4o",
+            provider="openai",
+            complexity_range=(TaskComplexity.MODERATE, TaskComplexity.COMPLEX),
+            cost_per_1k_tokens=0.0075,
+            capabilities=["text", "vision", "function-calling"],
+            context_window=128000
+        ),
+        ModelProfile(
+            name="anthropic/claude-3-haiku-20240307",
+            provider="anthropic",
+            complexity_range=(TaskComplexity.SIMPLE, TaskComplexity.MODERATE),
+            cost_per_1k_tokens=0.0008,
+            capabilities=["text", "function-calling"],
+            context_window=200000
+        ),
+        ModelProfile(
+            name="anthropic/claude-3-5-sonnet-20241022",
+            provider="anthropic",
+            complexity_range=(TaskComplexity.MODERATE, TaskComplexity.VERY_COMPLEX),
+            cost_per_1k_tokens=0.009,
+            capabilities=["text", "vision", "function-calling"],
+            context_window=200000,
+            strengths=["reasoning", "code-generation", "analysis"]
+        ),
+        ModelProfile(
+            name="gemini/gemini-1.5-flash",
+            provider="google",
+            complexity_range=(TaskComplexity.SIMPLE, TaskComplexity.MODERATE),
+            cost_per_1k_tokens=0.000125,
+            capabilities=["text", "vision", "function-calling"],
+            context_window=1048576
+        ),
+        ModelProfile(
+            name="gemini/gemini-1.5-pro",
+            provider="google",
+            complexity_range=(TaskComplexity.COMPLEX, TaskComplexity.VERY_COMPLEX),
+            cost_per_1k_tokens=0.00625,
+            capabilities=["text", "vision", "function-calling"],
+            context_window=2097152
+        ),
+    ]
+    
+    def __init__(self, verbose: bool = False):
+        """Initialize RouterHandler with model routing support."""
+        super().__init__(verbose=verbose)
+        self._model_router: Optional[List[ModelProfile]] = None
+        self._custom_models: Dict[str, ModelProfile] = {}
+        self._cost_threshold: Optional[float] = None
+        self._model_tiers = self.DEFAULT_MODEL_TIERS.copy()
+    
+    @property
+    def model_router(self) -> List[ModelProfile]:
+        """Get the list of available model profiles."""
+        if self._model_router is None:
+            return self.DEFAULT_MODELS.copy()
+        return self._model_router
+    
     @property
     def feature_name(self) -> str:
         return "router"
@@ -94,17 +196,29 @@ class RouterHandler(FlagHandler):
             Selected model name
         """
         complexity = self.analyze_complexity(prompt)
-        models = self.MODEL_TIERS.get(complexity, self.MODEL_TIERS['medium'])
+        
+        # If custom models are loaded, use ModelProfile-based selection
+        if self._custom_models:
+            return self._select_from_profiles(prompt, complexity, preferred_provider)
+        
+        # Otherwise use tier-based selection
+        models = self._model_tiers.get(complexity, self._model_tiers['medium'])
         
         # Filter by provider if specified
         if preferred_provider:
             provider_prefixes = {
                 'openai': ['gpt-', 'o1-'],
-                'anthropic': ['claude-'],
-                'google': ['gemini-']
+                'anthropic': ['anthropic/', 'claude-'],
+                'google': ['gemini/', 'gemini-']
             }
             prefixes = provider_prefixes.get(preferred_provider.lower(), [])
-            filtered = [m for m in models if any(m.startswith(p) for p in prefixes)]
+            filtered = [m for m in models if any(p in m for p in prefixes)]
+            if filtered:
+                models = filtered
+        
+        # Apply cost threshold if set
+        if self._cost_threshold:
+            filtered = [m for m in models if self.get_model_cost(m) <= self._cost_threshold]
             if filtered:
                 models = filtered
         
@@ -115,6 +229,48 @@ class RouterHandler(FlagHandler):
         
         return selected
     
+    def _select_from_profiles(
+        self, 
+        prompt: str, 
+        complexity: str, 
+        preferred_provider: str = None
+    ) -> str:
+        """Select model from custom ModelProfile objects."""
+        # Map string complexity to TaskComplexity enum
+        complexity_map = {
+            'simple': TaskComplexity.SIMPLE,
+            'medium': TaskComplexity.MODERATE,
+            'complex': TaskComplexity.COMPLEX,
+        }
+        task_complexity = complexity_map.get(complexity, TaskComplexity.MODERATE)
+        
+        # Get all models that support this complexity level
+        candidates = []
+        for name, profile in self._custom_models.items():
+            min_c, max_c = profile.complexity_range
+            if min_c.value <= task_complexity.value <= max_c.value:
+                candidates.append(profile)
+        
+        if not candidates:
+            return 'gpt-4o-mini'
+        
+        # Filter by provider if specified
+        if preferred_provider:
+            filtered = [m for m in candidates if m.provider == preferred_provider]
+            if filtered:
+                candidates = filtered
+        
+        # Filter by cost threshold if set
+        if self._cost_threshold:
+            filtered = [m for m in candidates if m.cost_per_1k_tokens <= self._cost_threshold]
+            if filtered:
+                candidates = filtered
+        
+        # Sort by cost (cheapest first)
+        candidates.sort(key=lambda m: m.cost_per_1k_tokens)
+        
+        return candidates[0].name if candidates else 'gpt-4o-mini'
+    
     def apply_to_agent_config(self, config: Dict[str, Any], flag_value: Any) -> Dict[str, Any]:
         """
         Apply router configuration.
@@ -158,3 +314,153 @@ class RouterHandler(FlagHandler):
             return 'gpt-4o-mini'  # Default
         
         return self.select_model(prompt, provider)
+    
+    # =========================================================================
+    # Custom Model Configuration Methods
+    # =========================================================================
+    
+    def yaml_to_model_profile(self, name: str, config: Dict[str, Any]) -> ModelProfile:
+        """
+        Convert YAML model configuration to ModelProfile object.
+        
+        Args:
+            name: Model name
+            config: Model configuration from YAML
+            
+        Returns:
+            ModelProfile object
+        """
+        # Parse complexity strings to TaskComplexity enum
+        complexity_list = config.get('complexity', ['moderate'])
+        complexity_map = {
+            'simple': TaskComplexity.SIMPLE,
+            'moderate': TaskComplexity.MODERATE,
+            'complex': TaskComplexity.COMPLEX,
+            'very_complex': TaskComplexity.VERY_COMPLEX,
+        }
+        
+        complexities = [complexity_map.get(c.lower(), TaskComplexity.MODERATE) for c in complexity_list]
+        min_complexity = min(complexities, key=lambda x: x.value)
+        max_complexity = max(complexities, key=lambda x: x.value)
+        
+        return ModelProfile(
+            name=name,
+            provider=config.get('provider', 'unknown'),
+            complexity_range=(min_complexity, max_complexity),
+            cost_per_1k_tokens=config.get('cost_per_1k', 0.001),
+            capabilities=config.get('capabilities', ['text']),
+            context_window=config.get('context_window', 128000),
+            supports_tools=config.get('supports_tools', True),
+            supports_streaming=config.get('supports_streaming', True),
+            strengths=config.get('strengths', None)
+        )
+    
+    def load_models_from_config(
+        self, 
+        models_config: Dict[str, Dict[str, Any]], 
+        merge_with_defaults: bool = False
+    ) -> None:
+        """
+        Load custom models from YAML configuration.
+        
+        Args:
+            models_config: Dictionary of model configurations from YAML
+            merge_with_defaults: If True, merge with default models
+        """
+        # Start with defaults if merging
+        if merge_with_defaults:
+            for profile in self.DEFAULT_MODELS:
+                self._custom_models[profile.name] = profile
+        
+        # Add custom models
+        for name, config in models_config.items():
+            profile = self.yaml_to_model_profile(name, config)
+            self._custom_models[name] = profile
+        
+        # Rebuild model tiers from profiles
+        self._rebuild_model_tiers()
+    
+    def _rebuild_model_tiers(self) -> None:
+        """Rebuild MODEL_TIERS from custom model profiles."""
+        self._model_tiers = {
+            'simple': [],
+            'medium': [],
+            'complex': [],
+        }
+        
+        for name, profile in self._custom_models.items():
+            min_c, max_c = profile.complexity_range
+            
+            if min_c.value <= TaskComplexity.SIMPLE.value <= max_c.value:
+                self._model_tiers['simple'].append(name)
+            if min_c.value <= TaskComplexity.MODERATE.value <= max_c.value:
+                self._model_tiers['medium'].append(name)
+            if min_c.value <= TaskComplexity.COMPLEX.value <= max_c.value:
+                self._model_tiers['complex'].append(name)
+        
+        # Sort by cost (cheapest first)
+        for tier in self._model_tiers:
+            self._model_tiers[tier].sort(
+                key=lambda n: self._custom_models[n].cost_per_1k_tokens
+            )
+    
+    def get_available_models(self) -> List[str]:
+        """
+        Get list of available model names.
+        
+        Returns:
+            List of model names
+        """
+        if self._custom_models:
+            return list(self._custom_models.keys())
+        return [p.name for p in self.DEFAULT_MODELS]
+    
+    def get_model_cost(self, model_name: str) -> float:
+        """
+        Get cost per 1k tokens for a model.
+        
+        Args:
+            model_name: Name of the model
+            
+        Returns:
+            Cost per 1k tokens
+        """
+        # Check custom models first
+        if model_name in self._custom_models:
+            return self._custom_models[model_name].cost_per_1k_tokens
+        
+        # Check default models
+        for profile in self.DEFAULT_MODELS:
+            if profile.name == model_name:
+                return profile.cost_per_1k_tokens
+        
+        # Default cost for unknown models
+        return 0.01
+    
+    def set_cost_threshold(self, threshold: float) -> None:
+        """
+        Set maximum cost per 1k tokens for model selection.
+        
+        Args:
+            threshold: Maximum cost per 1k tokens
+        """
+        self._cost_threshold = threshold
+    
+    def get_model_profile(self, model_name: str) -> Optional[ModelProfile]:
+        """
+        Get ModelProfile for a model.
+        
+        Args:
+            model_name: Name of the model
+            
+        Returns:
+            ModelProfile or None if not found
+        """
+        if model_name in self._custom_models:
+            return self._custom_models[model_name]
+        
+        for profile in self.DEFAULT_MODELS:
+            if profile.name == model_name:
+                return profile
+        
+        return None

src/praisonai/praisonai/cli/features/sandbox_executor.py

@@ -0,0 +1,515 @@
+"""
+Sandboxed Execution System for PraisonAI CLI.
+
+Inspired by Codex CLI's sandbox modes for secure command execution.
+Provides isolated execution environment when enabled via --sandbox flag.
+
+Architecture:
+- SandboxExecutor: Base class for sandboxed execution
+- SubprocessSandbox: Subprocess-based isolation with resource limits
+- SandboxPolicy: Configurable security policies
+
+Note: Sandbox is ONLY activated when explicitly requested via CLI flag.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set
+from pathlib import Path
+from enum import Enum
+import subprocess
+import logging
+import tempfile
+import shutil
+import time
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Sandbox Modes
+# ============================================================================
+
+class SandboxMode(Enum):
+    """
+    Sandbox execution modes.
+    
+    - DISABLED: No sandboxing (default)
+    - BASIC: Basic isolation with resource limits
+    - STRICT: Strict isolation with filesystem restrictions
+    - NETWORK_ISOLATED: No network access
+    """
+    DISABLED = "disabled"
+    BASIC = "basic"
+    STRICT = "strict"
+    NETWORK_ISOLATED = "network_isolated"
+    
+    @classmethod
+    def from_string(cls, value: str) -> "SandboxMode":
+        """Parse mode from string."""
+        value = value.lower().strip().replace("-", "_")
+        for mode in cls:
+            if mode.value == value:
+                return mode
+        raise ValueError(f"Unknown sandbox mode: {value}")
+
+
+# ============================================================================
+# Data Classes
+# ============================================================================
+
+@dataclass
+class SandboxPolicy:
+    """
+    Security policy for sandbox execution.
+    """
+    mode: SandboxMode = SandboxMode.DISABLED
+    
+    # Resource limits
+    max_memory_mb: int = 512
+    max_cpu_seconds: int = 30
+    max_file_size_mb: int = 10
+    max_processes: int = 10
+    
+    # Filesystem restrictions
+    allowed_paths: Set[str] = field(default_factory=set)
+    blocked_paths: Set[str] = field(default_factory=lambda: {
+        "/etc", "/var", "/usr", "/bin", "/sbin",
+        "/root", "/home", "/sys", "/proc"
+    })
+    temp_dir: Optional[str] = None
+    
+    # Network restrictions
+    allow_network: bool = True
+    allowed_hosts: Set[str] = field(default_factory=set)
+    
+    # Command restrictions
+    blocked_commands: Set[str] = field(default_factory=lambda: {
+        "rm", "rmdir", "mv", "dd", "mkfs", "fdisk",
+        "sudo", "su", "chmod", "chown", "kill", "pkill"
+    })
+    
+    @classmethod
+    def for_mode(cls, mode: SandboxMode) -> "SandboxPolicy":
+        """Create policy for a given mode."""
+        if mode == SandboxMode.DISABLED:
+            return cls(mode=mode)
+        
+        elif mode == SandboxMode.BASIC:
+            return cls(
+                mode=mode,
+                max_memory_mb=512,
+                max_cpu_seconds=60,
+                allow_network=True
+            )
+        
+        elif mode == SandboxMode.STRICT:
+            return cls(
+                mode=mode,
+                max_memory_mb=256,
+                max_cpu_seconds=30,
+                max_processes=5,
+                allow_network=True,
+                blocked_commands={
+                    "rm", "rmdir", "mv", "dd", "mkfs", "fdisk",
+                    "sudo", "su", "chmod", "chown", "kill", "pkill",
+                    "curl", "wget", "nc", "netcat", "ssh", "scp"
+                }
+            )
+        
+        elif mode == SandboxMode.NETWORK_ISOLATED:
+            return cls(
+                mode=mode,
+                max_memory_mb=512,
+                max_cpu_seconds=60,
+                allow_network=False
+            )
+        
+        return cls(mode=mode)
+
+
+@dataclass
+class ExecutionResult:
+    """Result of sandboxed execution."""
+    success: bool
+    exit_code: int
+    stdout: str
+    stderr: str
+    duration_ms: float
+    was_sandboxed: bool
+    policy_violations: List[str] = field(default_factory=list)
+    
+    @property
+    def output(self) -> str:
+        """Get combined output."""
+        return self.stdout + self.stderr
+
+
+# ============================================================================
+# Command Validator
+# ============================================================================
+
+class CommandValidator:
+    """
+    Validates commands against sandbox policy.
+    """
+    
+    def __init__(self, policy: SandboxPolicy):
+        self.policy = policy
+    
+    def validate(self, command: str) -> List[str]:
+        """
+        Validate a command against the policy.
+        
+        Returns:
+            List of policy violations (empty if valid)
+        """
+        violations = []
+        
+        if self.policy.mode == SandboxMode.DISABLED:
+            return violations
+        
+        # Parse command
+        parts = command.split()
+        if not parts:
+            return violations
+        
+        cmd_name = Path(parts[0]).name
+        
+        # Check blocked commands
+        if cmd_name in self.policy.blocked_commands:
+            violations.append(f"Command '{cmd_name}' is blocked by sandbox policy")
+        
+        # Check for dangerous patterns
+        dangerous_patterns = [
+            ("rm -rf", "Recursive force delete is blocked"),
+            ("> /dev/", "Writing to device files is blocked"),
+            ("| sh", "Piping to shell is blocked"),
+            ("| bash", "Piping to bash is blocked"),
+            ("$(", "Command substitution is blocked"),
+            ("`", "Backtick command substitution is blocked"),
+        ]
+        
+        for pattern, message in dangerous_patterns:
+            if pattern in command:
+                violations.append(message)
+        
+        # Check path access
+        for part in parts:
+            if part.startswith("/"):
+                for blocked in self.policy.blocked_paths:
+                    if part.startswith(blocked):
+                        violations.append(f"Access to '{blocked}' is blocked")
+                        break
+        
+        return violations
+    
+    def is_allowed(self, command: str) -> bool:
+        """Check if command is allowed."""
+        return len(self.validate(command)) == 0
+
+
+# ============================================================================
+# Subprocess Sandbox
+# ============================================================================
+
+class SubprocessSandbox:
+    """
+    Subprocess-based sandbox execution.
+    
+    Provides basic isolation through:
+    - Resource limits (timeout, memory via ulimit)
+    - Working directory isolation
+    - Environment variable control
+    - Command validation
+    """
+    
+    def __init__(
+        self,
+        policy: Optional[SandboxPolicy] = None,
+        working_dir: Optional[str] = None,
+        verbose: bool = False
+    ):
+        self.policy = policy or SandboxPolicy()
+        self.working_dir = Path(working_dir) if working_dir else Path.cwd()
+        self.verbose = verbose
+        self.validator = CommandValidator(self.policy)
+        
+        self._temp_dir: Optional[Path] = None
+    
+    def _setup_temp_dir(self) -> Path:
+        """Set up temporary directory for isolated execution."""
+        if self._temp_dir is None:
+            self._temp_dir = Path(tempfile.mkdtemp(prefix="praisonai_sandbox_"))
+        return self._temp_dir
+    
+    def _cleanup_temp_dir(self) -> None:
+        """Clean up temporary directory."""
+        if self._temp_dir and self._temp_dir.exists():
+            try:
+                shutil.rmtree(self._temp_dir)
+            except Exception as e:
+                logger.debug(f"Failed to cleanup temp dir: {e}")
+            self._temp_dir = None
+    
+    def _build_environment(self) -> Dict[str, str]:
+        """Build restricted environment variables."""
+        import os
+        
+        # Start with minimal environment
+        env = {
+            "PATH": "/usr/local/bin:/usr/bin:/bin",
+            "HOME": str(self._temp_dir or self.working_dir),
+            "TERM": "xterm",
+            "LANG": "en_US.UTF-8",
+        }
+        
+        # Add some safe variables from current environment
+        safe_vars = ["USER", "SHELL", "PYTHONPATH"]
+        for var in safe_vars:
+            if var in os.environ:
+                env[var] = os.environ[var]
+        
+        return env
+    
+    def execute(
+        self,
+        command: str,
+        timeout: Optional[float] = None,
+        capture_output: bool = True
+    ) -> ExecutionResult:
+        """
+        Execute a command in the sandbox.
+        
+        Args:
+            command: Command to execute
+            timeout: Timeout in seconds (overrides policy)
+            capture_output: Whether to capture stdout/stderr
+            
+        Returns:
+            ExecutionResult with execution details
+        """
+        start_time = time.time()
+        
+        # Check if sandbox is enabled
+        if self.policy.mode == SandboxMode.DISABLED:
+            return self._execute_unsandboxed(command, timeout, capture_output)
+        
+        # Validate command
+        violations = self.validator.validate(command)
+        if violations:
+            return ExecutionResult(
+                success=False,
+                exit_code=-1,
+                stdout="",
+                stderr="Command blocked by sandbox policy:\n" + "\n".join(violations),
+                duration_ms=(time.time() - start_time) * 1000,
+                was_sandboxed=True,
+                policy_violations=violations
+            )
+        
+        # Set up sandbox
+        if self.policy.mode == SandboxMode.STRICT:
+            self._setup_temp_dir()
+            cwd = self._temp_dir
+        else:
+            cwd = self.working_dir
+        
+        # Build environment
+        env = self._build_environment()
+        
+        # Set timeout
+        if timeout is None:
+            timeout = float(self.policy.max_cpu_seconds)
+        
+        # Execute
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                cwd=cwd,
+                env=env,
+                capture_output=capture_output,
+                text=True,
+                timeout=timeout
+            )
+            
+            return ExecutionResult(
+                success=result.returncode == 0,
+                exit_code=result.returncode,
+                stdout=result.stdout if capture_output else "",
+                stderr=result.stderr if capture_output else "",
+                duration_ms=(time.time() - start_time) * 1000,
+                was_sandboxed=True
+            )
+        
+        except subprocess.TimeoutExpired:
+            return ExecutionResult(
+                success=False,
+                exit_code=-1,
+                stdout="",
+                stderr=f"Command timed out after {timeout}s",
+                duration_ms=(time.time() - start_time) * 1000,
+                was_sandboxed=True,
+                policy_violations=["Timeout exceeded"]
+            )
+        
+        except Exception as e:
+            return ExecutionResult(
+                success=False,
+                exit_code=-1,
+                stdout="",
+                stderr=str(e),
+                duration_ms=(time.time() - start_time) * 1000,
+                was_sandboxed=True,
+                policy_violations=[str(e)]
+            )
+        
+        finally:
+            if self.policy.mode == SandboxMode.STRICT:
+                self._cleanup_temp_dir()
+    
+    def _execute_unsandboxed(
+        self,
+        command: str,
+        timeout: Optional[float],
+        capture_output: bool
+    ) -> ExecutionResult:
+        """Execute without sandbox (when disabled)."""
+        start_time = time.time()
+        
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                cwd=self.working_dir,
+                capture_output=capture_output,
+                text=True,
+                timeout=timeout
+            )
+            
+            return ExecutionResult(
+                success=result.returncode == 0,
+                exit_code=result.returncode,
+                stdout=result.stdout if capture_output else "",
+                stderr=result.stderr if capture_output else "",
+                duration_ms=(time.time() - start_time) * 1000,
+                was_sandboxed=False
+            )
+        
+        except subprocess.TimeoutExpired:
+            return ExecutionResult(
+                success=False,
+                exit_code=-1,
+                stdout="",
+                stderr=f"Command timed out after {timeout}s",
+                duration_ms=(time.time() - start_time) * 1000,
+                was_sandboxed=False
+            )
+        
+        except Exception as e:
+            return ExecutionResult(
+                success=False,
+                exit_code=-1,
+                stdout="",
+                stderr=str(e),
+                duration_ms=(time.time() - start_time) * 1000,
+                was_sandboxed=False
+            )
+
+
+# ============================================================================
+# CLI Integration Handler
+# ============================================================================
+
+class SandboxExecutorHandler:
+    """
+    Handler for integrating Sandbox Execution with PraisonAI CLI.
+    
+    Note: Sandbox is ONLY activated when --sandbox flag is passed.
+    """
+    
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self._sandbox: Optional[SubprocessSandbox] = None
+        self._enabled: bool = False
+    
+    @property
+    def feature_name(self) -> str:
+        return "sandbox_executor"
+    
+    @property
+    def is_enabled(self) -> bool:
+        """Check if sandbox is enabled."""
+        return self._enabled
+    
+    def initialize(
+        self,
+        mode: str = "disabled",
+        working_dir: Optional[str] = None,
+        policy: Optional[SandboxPolicy] = None
+    ) -> SubprocessSandbox:
+        """
+        Initialize the sandbox.
+        
+        Args:
+            mode: Sandbox mode (disabled, basic, strict, network_isolated)
+            working_dir: Working directory for execution
+            policy: Optional custom policy
+            
+        Returns:
+            Configured SubprocessSandbox
+        """
+        try:
+            sandbox_mode = SandboxMode.from_string(mode)
+        except ValueError:
+            logger.warning(f"Unknown sandbox mode '{mode}', defaulting to 'disabled'")
+            sandbox_mode = SandboxMode.DISABLED
+        
+        if policy is None:
+            policy = SandboxPolicy.for_mode(sandbox_mode)
+        
+        self._sandbox = SubprocessSandbox(
+            policy=policy,
+            working_dir=working_dir,
+            verbose=self.verbose
+        )
+        
+        self._enabled = sandbox_mode != SandboxMode.DISABLED
+        
+        if self.verbose and self._enabled:
+            from rich import print as rprint
+            rprint(f"[yellow]⚠ Sandbox enabled: {sandbox_mode.value}[/yellow]")
+        
+        return self._sandbox
+    
+    def get_sandbox(self) -> Optional[SubprocessSandbox]:
+        """Get the sandbox executor."""
+        return self._sandbox
+    
+    def execute(
+        self,
+        command: str,
+        timeout: Optional[float] = None
+    ) -> ExecutionResult:
+        """
+        Execute a command.
+        
+        If sandbox is not initialized, runs without sandboxing.
+        """
+        if not self._sandbox:
+            self._sandbox = self.initialize()
+        
+        return self._sandbox.execute(command, timeout=timeout)
+    
+    def validate_command(self, command: str) -> List[str]:
+        """Validate a command against sandbox policy."""
+        if not self._sandbox:
+            return []
+        
+        return self._sandbox.validator.validate(command)
+    
+    def get_mode(self) -> str:
+        """Get current sandbox mode."""
+        if self._sandbox:
+            return self._sandbox.policy.mode.value
+        return SandboxMode.DISABLED.value

src/praisonai/praisonai/cli/features/slash_commands.py

@@ -0,0 +1,650 @@
+"""
+Slash Commands System for PraisonAI CLI.
+
+Inspired by Aider's command system and Gemini CLI's slash commands.
+Provides interactive commands like /help, /cost, /plan, /model, /clear, etc.
+
+Architecture:
+- SlashCommand: Base class for all commands
+- SlashCommandRegistry: Manages command registration and lookup
+- SlashCommandParser: Parses user input for slash commands
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
+from enum import Enum
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class CommandKind(Enum):
+    """Type of slash command."""
+    BUILT_IN = "built_in"
+    CUSTOM = "custom"
+    MCP = "mcp"
+
+
+@dataclass
+class SlashCommand:
+    """
+    Represents a slash command.
+    
+    Attributes:
+        name: Primary command name (e.g., "help", "cost")
+        description: Short description for help text
+        action: Callable that executes the command
+        alt_names: Alternative names/aliases
+        sub_commands: Nested sub-commands
+        kind: Type of command (built-in, custom, MCP)
+        auto_execute: Whether to execute without confirmation
+    """
+    name: str
+    description: str
+    action: Optional[Callable[["CommandContext", str], Any]] = None
+    alt_names: List[str] = field(default_factory=list)
+    sub_commands: List["SlashCommand"] = field(default_factory=list)
+    kind: CommandKind = CommandKind.BUILT_IN
+    auto_execute: bool = True
+    
+    def __post_init__(self):
+        """Validate command after initialization."""
+        if not self.name:
+            raise ValueError("Command name cannot be empty")
+        if not self.name.isalnum() and "_" not in self.name and "-" not in self.name:
+            raise ValueError(f"Invalid command name: {self.name}")
+
+
+@dataclass
+class CommandContext:
+    """
+    Context passed to command actions.
+    
+    Contains all services and state needed by commands.
+    """
+    # Core services
+    agent: Any = None  # PraisonAI Agent instance
+    config: Dict[str, Any] = field(default_factory=dict)
+    
+    # Session state
+    session_id: Optional[str] = None
+    session_start_time: Optional[float] = None
+    
+    # Metrics
+    total_tokens: int = 0
+    total_cost: float = 0.0
+    prompt_count: int = 0
+    
+    # UI callbacks
+    print_fn: Callable[[str], None] = print
+    input_fn: Callable[[str], str] = input
+    
+    # Command invocation info
+    raw_input: str = ""
+    command_name: str = ""
+    args: str = ""
+
+
+@dataclass
+class ParsedSlashCommand:
+    """Result of parsing a slash command."""
+    command: Optional[SlashCommand] = None
+    args: str = ""
+    canonical_path: List[str] = field(default_factory=list)
+    error: Optional[str] = None
+
+
+class SlashCommandRegistry:
+    """
+    Registry for slash commands.
+    
+    Manages command registration, lookup, and help generation.
+    """
+    
+    def __init__(self):
+        self._commands: Dict[str, SlashCommand] = {}
+        self._aliases: Dict[str, str] = {}  # alias -> primary name
+    
+    def register(self, command: SlashCommand) -> None:
+        """Register a slash command."""
+        if command.name in self._commands:
+            logger.warning(f"Overwriting existing command: {command.name}")
+        
+        self._commands[command.name] = command
+        
+        # Register aliases
+        for alias in command.alt_names:
+            if alias in self._aliases:
+                logger.warning(f"Alias '{alias}' already registered")
+            self._aliases[alias] = command.name
+    
+    def unregister(self, name: str) -> bool:
+        """Unregister a command by name."""
+        if name in self._commands:
+            cmd = self._commands.pop(name)
+            # Remove aliases
+            for alias in cmd.alt_names:
+                self._aliases.pop(alias, None)
+            return True
+        return False
+    
+    def get(self, name: str) -> Optional[SlashCommand]:
+        """Get a command by name or alias."""
+        # Check primary name first
+        if name in self._commands:
+            return self._commands[name]
+        # Check aliases
+        if name in self._aliases:
+            return self._commands.get(self._aliases[name])
+        return None
+    
+    def get_all(self) -> List[SlashCommand]:
+        """Get all registered commands."""
+        return list(self._commands.values())
+    
+    def get_names(self) -> List[str]:
+        """Get all command names (including aliases)."""
+        names = list(self._commands.keys())
+        names.extend(self._aliases.keys())
+        return sorted(set(names))
+
+
+class SlashCommandParser:
+    """
+    Parser for slash commands.
+    
+    Handles parsing of user input into command and arguments.
+    """
+    
+    def __init__(self, registry: SlashCommandRegistry):
+        self.registry = registry
+    
+    def is_slash_command(self, query: str) -> bool:
+        """Check if input is a slash command."""
+        query = query.strip()
+        if not query.startswith('/'):
+            return False
+        # Exclude code comments
+        if query.startswith('//') or query.startswith('/*'):
+            return False
+        return True
+    
+    def parse(self, query: str) -> ParsedSlashCommand:
+        """
+        Parse a slash command string.
+        
+        Args:
+            query: Raw input string (e.g., "/help model" or "/cost")
+            
+        Returns:
+            ParsedSlashCommand with resolved command and arguments
+        """
+        if not self.is_slash_command(query):
+            return ParsedSlashCommand(error="Not a slash command")
+        
+        trimmed = query.strip()
+        parts = trimmed[1:].strip().split()  # Remove leading /
+        
+        if not parts:
+            return ParsedSlashCommand(error="Empty command")
+        
+        command_path = parts
+        canonical_path: List[str] = []
+        current_commands = self.registry.get_all()
+        command_to_execute: Optional[SlashCommand] = None
+        path_index = 0
+        
+        for part in command_path:
+            # First pass: exact match on primary name
+            found_command = None
+            for cmd in current_commands:
+                if cmd.name == part:
+                    found_command = cmd
+                    break
+            
+            # Second pass: check aliases
+            if not found_command:
+                for cmd in current_commands:
+                    if part in cmd.alt_names:
+                        found_command = cmd
+                        break
+            
+            if found_command:
+                command_to_execute = found_command
+                canonical_path.append(found_command.name)
+                path_index += 1
+                if found_command.sub_commands:
+                    current_commands = found_command.sub_commands
+                else:
+                    break
+            else:
+                break
+        
+        args = ' '.join(parts[path_index:])
+        
+        return ParsedSlashCommand(
+            command=command_to_execute,
+            args=args,
+            canonical_path=canonical_path
+        )
+
+
+# ============================================================================
+# Built-in Commands
+# ============================================================================
+
+def cmd_help(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Show help for commands."""
+    from rich.console import Console
+    from rich.table import Table
+    
+    console = Console()
+    
+    if args:
+        # Help for specific command
+        registry = context.config.get("command_registry")
+        if registry:
+            cmd = registry.get(args)
+            if cmd:
+                console.print(f"\n[bold cyan]/{cmd.name}[/bold cyan]")
+                console.print(f"  {cmd.description}")
+                if cmd.alt_names:
+                    console.print(f"  Aliases: {', '.join(cmd.alt_names)}")
+                if cmd.sub_commands:
+                    console.print("\n  Sub-commands:")
+                    for sub in cmd.sub_commands:
+                        console.print(f"    /{cmd.name} {sub.name} - {sub.description}")
+                return {"type": "help", "command": cmd.name}
+            else:
+                console.print(f"[red]Unknown command: {args}[/red]")
+                return {"type": "error", "message": f"Unknown command: {args}"}
+    
+    # General help
+    table = Table(title="Available Commands", show_header=True)
+    table.add_column("Command", style="cyan")
+    table.add_column("Description")
+    
+    registry = context.config.get("command_registry")
+    if registry:
+        for cmd in registry.get_all():
+            aliases = f" ({', '.join(cmd.alt_names)})" if cmd.alt_names else ""
+            table.add_row(f"/{cmd.name}{aliases}", cmd.description)
+    
+    console.print(table)
+    return {"type": "help"}
+
+
+def cmd_cost(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Show session cost and token usage."""
+    from rich.console import Console
+    from rich.panel import Panel
+    
+    console = Console()
+    
+    cost_info = f"""
+[bold]Session Statistics[/bold]
+
+Total Tokens: {context.total_tokens:,}
+Total Cost: ${context.total_cost:.4f}
+Prompts: {context.prompt_count}
+"""
+    
+    if context.session_start_time:
+        import time
+        duration = time.time() - context.session_start_time
+        minutes = int(duration // 60)
+        seconds = int(duration % 60)
+        cost_info += f"Duration: {minutes}m {seconds}s\n"
+    
+    console.print(Panel(cost_info, title="💰 Cost Tracker", border_style="green"))
+    
+    return {
+        "type": "stats",
+        "tokens": context.total_tokens,
+        "cost": context.total_cost,
+        "prompts": context.prompt_count
+    }
+
+
+def cmd_clear(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Clear the conversation history."""
+    from rich.console import Console
+    console = Console()
+    
+    # Reset agent conversation if available
+    if context.agent and hasattr(context.agent, 'clear_history'):
+        context.agent.clear_history()
+    
+    console.print("[green]✓ Conversation cleared[/green]")
+    return {"type": "clear"}
+
+
+def cmd_model(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Show or change the current model."""
+    from rich.console import Console
+    console = Console()
+    
+    if args:
+        # Change model
+        if context.agent and hasattr(context.agent, 'set_model'):
+            context.agent.set_model(args)
+            console.print(f"[green]✓ Model changed to: {args}[/green]")
+            return {"type": "model_change", "model": args}
+        else:
+            console.print(f"[yellow]Model change requested: {args}[/yellow]")
+            return {"type": "model_change", "model": args}
+    else:
+        # Show current model
+        current_model = "unknown"
+        if context.agent and hasattr(context.agent, 'llm'):
+            current_model = getattr(context.agent.llm, 'model', 'unknown')
+        console.print(f"[cyan]Current model: {current_model}[/cyan]")
+        return {"type": "model_info", "model": current_model}
+
+
+def cmd_tokens(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Show token usage breakdown."""
+    from rich.console import Console
+    from rich.table import Table
+    
+    console = Console()
+    
+    table = Table(title="Token Usage", show_header=True)
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value", justify="right")
+    
+    table.add_row("Total Tokens", f"{context.total_tokens:,}")
+    table.add_row("Prompts Sent", str(context.prompt_count))
+    if context.prompt_count > 0:
+        avg = context.total_tokens / context.prompt_count
+        table.add_row("Avg Tokens/Prompt", f"{avg:.0f}")
+    
+    console.print(table)
+    return {"type": "tokens", "total": context.total_tokens}
+
+
+def cmd_plan(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Show or create an execution plan."""
+    from rich.console import Console
+    console = Console()
+    
+    if args:
+        console.print(f"[cyan]Creating plan for: {args}[/cyan]")
+        # Trigger planning mode
+        return {"type": "submit_prompt", "content": f"Create a detailed plan for: {args}"}
+    else:
+        console.print("[yellow]Usage: /plan <task description>[/yellow]")
+        return {"type": "help", "command": "plan"}
+
+
+def cmd_undo(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Undo the last change."""
+    from rich.console import Console
+    console = Console()
+    
+    # Check for git integration
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["git", "diff", "--stat", "HEAD~1"],
+            capture_output=True,
+            text=True,
+            cwd="."
+        )
+        if result.returncode == 0:
+            console.print("[yellow]Last commit changes:[/yellow]")
+            console.print(result.stdout)
+            console.print("\n[cyan]Run 'git reset --soft HEAD~1' to undo[/cyan]")
+        else:
+            console.print("[red]No git history available[/red]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+    
+    return {"type": "undo"}
+
+
+def cmd_diff(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Show git diff of changes."""
+    from rich.console import Console
+    from rich.syntax import Syntax
+    
+    console = Console()
+    
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["git", "diff"],
+            capture_output=True,
+            text=True,
+            cwd="."
+        )
+        if result.stdout:
+            syntax = Syntax(result.stdout, "diff", theme="monokai")
+            console.print(syntax)
+        else:
+            console.print("[green]No uncommitted changes[/green]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+    
+    return {"type": "diff"}
+
+
+def cmd_commit(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Commit changes with AI-generated message."""
+    from rich.console import Console
+    console = Console()
+    
+    console.print("[cyan]Generating commit message...[/cyan]")
+    
+    # This will trigger the commit command handler
+    return {"type": "commit", "message": args if args else None}
+
+
+def cmd_exit(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Exit the CLI."""
+    from rich.console import Console
+    console = Console()
+    
+    console.print("[yellow]Goodbye![/yellow]")
+    return {"type": "exit"}
+
+
+def cmd_settings(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Show current settings."""
+    from rich.console import Console
+    from rich.table import Table
+    
+    console = Console()
+    
+    table = Table(title="Current Settings", show_header=True)
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value")
+    
+    for key, value in context.config.items():
+        if key != "command_registry":  # Skip internal objects
+            table.add_row(key, str(value))
+    
+    console.print(table)
+    return {"type": "settings"}
+
+
+def cmd_map(context: CommandContext, args: str) -> Dict[str, Any]:
+    """Show repository map."""
+    from rich.console import Console
+    console = Console()
+    
+    console.print("[cyan]Generating repository map...[/cyan]")
+    # This will be implemented with RepoMap feature
+    return {"type": "map"}
+
+
+# ============================================================================
+# Registry Setup
+# ============================================================================
+
+def create_default_registry() -> SlashCommandRegistry:
+    """Create registry with default built-in commands."""
+    registry = SlashCommandRegistry()
+    
+    # Core commands
+    registry.register(SlashCommand(
+        name="help",
+        description="Show help for commands",
+        action=cmd_help,
+        alt_names=["h", "?"]
+    ))
+    
+    registry.register(SlashCommand(
+        name="cost",
+        description="Show session cost and token usage",
+        action=cmd_cost,
+        alt_names=["usage", "stats"]
+    ))
+    
+    registry.register(SlashCommand(
+        name="clear",
+        description="Clear conversation history",
+        action=cmd_clear,
+        alt_names=["reset"]
+    ))
+    
+    registry.register(SlashCommand(
+        name="model",
+        description="Show or change the current model",
+        action=cmd_model,
+        alt_names=["m"]
+    ))
+    
+    registry.register(SlashCommand(
+        name="tokens",
+        description="Show token usage breakdown",
+        action=cmd_tokens
+    ))
+    
+    registry.register(SlashCommand(
+        name="plan",
+        description="Create an execution plan for a task",
+        action=cmd_plan
+    ))
+    
+    registry.register(SlashCommand(
+        name="undo",
+        description="Undo the last change",
+        action=cmd_undo
+    ))
+    
+    registry.register(SlashCommand(
+        name="diff",
+        description="Show git diff of changes",
+        action=cmd_diff
+    ))
+    
+    registry.register(SlashCommand(
+        name="commit",
+        description="Commit changes with AI-generated message",
+        action=cmd_commit
+    ))
+    
+    registry.register(SlashCommand(
+        name="exit",
+        description="Exit the CLI",
+        action=cmd_exit,
+        alt_names=["quit", "q"]
+    ))
+    
+    registry.register(SlashCommand(
+        name="settings",
+        description="Show current settings",
+        action=cmd_settings
+    ))
+    
+    registry.register(SlashCommand(
+        name="map",
+        description="Show repository map",
+        action=cmd_map,
+        alt_names=["repo"]
+    ))
+    
+    return registry
+
+
+# ============================================================================
+# Handler for CLI Integration
+# ============================================================================
+
+class SlashCommandHandler:
+    """
+    Handler for integrating slash commands with PraisonAI CLI.
+    """
+    
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.registry = create_default_registry()
+        self.parser = SlashCommandParser(self.registry)
+        self._context: Optional[CommandContext] = None
+    
+    def set_context(self, context: CommandContext) -> None:
+        """Set the command context."""
+        self._context = context
+        context.config["command_registry"] = self.registry
+    
+    def is_command(self, query: str) -> bool:
+        """Check if input is a slash command."""
+        return self.parser.is_slash_command(query)
+    
+    def execute(self, query: str) -> Optional[Dict[str, Any]]:
+        """
+        Execute a slash command.
+        
+        Returns:
+            Command result dict or None if not a command
+        """
+        if not self.is_command(query):
+            return None
+        
+        parsed = self.parser.parse(query)
+        
+        if parsed.error:
+            if self.verbose:
+                print(f"[red]Error: {parsed.error}[/red]")
+            return {"type": "error", "message": parsed.error}
+        
+        if not parsed.command:
+            return {"type": "error", "message": "Unknown command"}
+        
+        if not parsed.command.action:
+            return {"type": "error", "message": f"Command '{parsed.command.name}' has no action"}
+        
+        # Create context if not set
+        if not self._context:
+            self._context = CommandContext()
+            self._context.config["command_registry"] = self.registry
+        
+        self._context.raw_input = query
+        self._context.command_name = parsed.command.name
+        self._context.args = parsed.args
+        
+        try:
+            result = parsed.command.action(self._context, parsed.args)
+            return result
+        except Exception as e:
+            logger.error(f"Error executing command: {e}")
+            return {"type": "error", "message": str(e)}
+    
+    def register_command(self, command: SlashCommand) -> None:
+        """Register a custom command."""
+        self.registry.register(command)
+    
+    def get_completions(self, partial: str) -> List[str]:
+        """Get command completions for partial input."""
+        if not partial.startswith('/'):
+            return []
+        
+        partial_cmd = partial[1:].lower()
+        completions = []
+        
+        for name in self.registry.get_names():
+            if name.lower().startswith(partial_cmd):
+                completions.append(f"/{name}")
+        
+        return sorted(completions)

src/praisonai/praisonai/cli/features/workflow.py

@@ -199,6 +199,73 @@ steps:
     repeat:
       until: "approved"
       max_iterations: 3
+""",
+        "model-routing": """# Model Routing Workflow
+name: Cost-Optimized Model Routing Workflow
+description: Uses custom models with automatic routing based on task complexity
+
+# Custom models configuration - define your own models with costs and capabilities
+models:
+  cheap-fast:
+    provider: openai
+    complexity: [simple]
+    cost_per_1k: 0.0001
+    capabilities: [text]
+    context_window: 16000
+  
+  balanced:
+    provider: openai
+    complexity: [moderate]
+    cost_per_1k: 0.001
+    capabilities: [text, function-calling]
+    context_window: 128000
+  
+  premium:
+    provider: anthropic
+    complexity: [complex, very_complex]
+    cost_per_1k: 0.015
+    capabilities: [text, vision, function-calling]
+    context_window: 200000
+    strengths: [reasoning, analysis, code-generation]
+
+workflow:
+  verbose: true
+  router: true  # Enable model routing
+  routing_strategy: cost-optimized  # Options: auto, cost-optimized, performance-optimized
+
+agents:
+  classifier:
+    name: Classifier
+    role: Request Classifier
+    goal: Classify incoming requests by complexity
+    instructions: "Classify the request as 'simple', 'moderate', or 'complex'."
+    llm: cheap-fast  # Always use cheap model for classification
+
+  researcher:
+    name: Researcher
+    role: Research Analyst
+    goal: Research topics thoroughly
+    instructions: "Research the topic and provide detailed findings."
+    llm_routing: auto  # Auto-select based on task complexity
+    llm_models: [balanced, premium]  # Models to choose from
+
+  writer:
+    name: Writer
+    role: Content Writer
+    goal: Write high-quality content
+    instructions: "Write clear, engaging content based on research."
+    llm: premium  # Always use premium for quality writing
+
+steps:
+  - agent: classifier
+    action: "Classify complexity of: {{input}}"
+    
+  - name: routing
+    route:
+      simple: [researcher]
+      moderate: [researcher]
+      complex: [researcher, writer]
+      default: [researcher]
 """
     }
     
@@ -224,7 +291,7 @@ Workflow Commands:
   praisonai workflow create --template <name>  - Create from template
   praisonai workflow auto "topic" --pattern <pattern>  - Auto-generate workflow
   
-Templates: simple, routing, parallel, loop, evaluator-optimizer
+Templates: simple, routing, parallel, loop, evaluator-optimizer, model-routing
 Patterns: sequential, routing, parallel
 
 Example:

src/praisonai/praisonai/cli/schedule_cli.py

@@ -0,0 +1,54 @@
+"""
+Simple CLI entry point for praisonai schedule command.
+
+This provides a standalone entry point that can be called from main.py
+"""
+
+import sys
+from praisonai.cli.features.agent_scheduler import AgentSchedulerHandler
+
+
+def main():
+    """Main entry point for schedule CLI command."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description='Schedule an agent to run continuously at regular intervals'
+    )
+    
+    parser.add_argument(
+        'schedule_yaml',
+        nargs='?',
+        default='agents.yaml',
+        help='Path to agents.yaml file (default: agents.yaml)'
+    )
+    
+    parser.add_argument(
+        '--interval',
+        dest='schedule_interval',
+        type=str,
+        help='Override schedule interval (e.g., "hourly", "*/30m", "daily")'
+    )
+    
+    parser.add_argument(
+        '--max-retries',
+        dest='schedule_max_retries',
+        type=int,
+        help='Override maximum retry attempts (default: from YAML or 3)'
+    )
+    
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        help='Enable verbose logging'
+    )
+    
+    args = parser.parse_args()
+    
+    # Call the handler
+    exit_code = AgentSchedulerHandler.handle_schedule_command(args)
+    sys.exit(exit_code)
+
+
+if __name__ == '__main__':
+    main()

src/praisonai/praisonai/deploy.py

@@ -57,7 +57,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.3.44 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.3.65 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

src/praisonai/praisonai/integrations/base.py

@@ -135,7 +135,8 @@ class BaseCLIIntegration(ABC):
             *cmd,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
-            cwd=self.workspace
+            cwd=self.workspace,
+            env=self.get_env()
         )
         
         try:
@@ -173,7 +174,8 @@ class BaseCLIIntegration(ABC):
             *cmd,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
-            cwd=self.workspace
+            cwd=self.workspace,
+            env=self.get_env()
         )
         
         try:
@@ -208,7 +210,8 @@ class BaseCLIIntegration(ABC):
             *cmd,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
-            cwd=self.workspace
+            cwd=self.workspace,
+            env=self.get_env()
         )
         
         try:

src/praisonai/praisonai/integrations/claude_code.py

@@ -127,23 +127,16 @@ class ClaudeCodeIntegration(BaseCLIIntegration):
         """
         cmd = ["claude"]
         
-        # Add continue flag if needed
-        if continue_session or self._session_active:
-            cmd.append("--continue")
-        
-        # Add skip permissions flag
-        if self.skip_permissions:
-            cmd.append("--dangerously-skip-permissions")
-        
-        # Add print mode flag
+        # Add print mode flag for non-interactive output
         cmd.append("-p")
         
-        # Add prompt
-        cmd.append(prompt)
-        
         # Add output format
         cmd.extend(["--output-format", self.output_format])
         
+        # Add continue flag if needed
+        if continue_session or self._session_active:
+            cmd.append("--continue")
+        
         # Add model if specified
         if self.model:
             cmd.extend(["--model", self.model])
@@ -160,6 +153,13 @@ class ClaudeCodeIntegration(BaseCLIIntegration):
         if self.disallowed_tools:
             cmd.extend(["--disallowedTools", ",".join(self.disallowed_tools)])
         
+        # Add verbose if needed
+        if options.get('verbose'):
+            cmd.append("--verbose")
+        
+        # Add prompt last
+        cmd.append(prompt)
+        
         return cmd
     
     async def execute(self, prompt: str, **options) -> str:

src/praisonai/praisonai/integrations/codex_cli.py

@@ -93,6 +93,9 @@ class CodexCLIIntegration(BaseCLIIntegration):
         """
         cmd = ["codex", "exec"]
         
+        # Add working directory
+        cmd.extend(["-C", self.workspace])
+        
         # Add task
         cmd.append(task)
         

src/praisonai/praisonai/integrations/cursor_cli.py

@@ -97,6 +97,9 @@ class CursorCLIIntegration(BaseCLIIntegration):
         # Add print mode flag
         cmd.append("-p")
         
+        # Add workspace
+        cmd.extend(["--workspace", self.workspace])
+        
         # Add force flag if enabled
         if self.force:
             cmd.append("--force")

src/praisonai/praisonai/integrations/gemini_cli.py

@@ -92,12 +92,6 @@ class GeminiCLIIntegration(BaseCLIIntegration):
         """
         cmd = ["gemini"]
         
-        # Add print mode flag
-        cmd.append("-p")
-        
-        # Add prompt
-        cmd.append(prompt)
-        
         # Add model
         cmd.extend(["-m", self.model])
         
@@ -112,6 +106,12 @@ class GeminiCLIIntegration(BaseCLIIntegration):
         if self.sandbox:
             cmd.append("--sandbox")
         
+        # Add YOLO mode for non-interactive execution
+        cmd.append("--yolo")
+        
+        # Add prompt as positional argument (must be last)
+        cmd.append(prompt)
+        
         return cmd
     
     async def execute(self, prompt: str, **options) -> str:

src/praisonai/praisonai/profiler.py

@@ -0,0 +1,465 @@
+"""
+PraisonAI Profiler Module
+
+Standardized profiling for performance monitoring across praisonai and praisonai-agents.
+
+Features:
+- Import timing
+- Function execution timing
+- Flow tracking
+- File/module usage tracking
+- Memory usage (optional)
+
+Usage:
+    from praisonai.profiler import Profiler, profile, profile_imports
+    
+    # Profile a function
+    @profile
+    def my_function():
+        pass
+    
+    # Profile a block
+    with Profiler.block("my_operation"):
+        do_something()
+    
+    # Profile imports
+    with profile_imports():
+        import heavy_module
+    
+    # Get report
+    Profiler.report()
+"""
+
+import time
+import functools
+import threading
+import sys
+import os
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Callable, Any
+from contextlib import contextmanager
+
+
+# ============================================================================
+# Data Classes
+# ============================================================================
+
+@dataclass
+class TimingRecord:
+    """Record of a single timing measurement."""
+    name: str
+    duration_ms: float
+    category: str = "function"
+    file: str = ""
+    line: int = 0
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class ImportRecord:
+    """Record of a module import."""
+    module: str
+    duration_ms: float
+    parent: str = ""
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class FlowRecord:
+    """Record of execution flow."""
+    step: int
+    name: str
+    file: str
+    line: int
+    duration_ms: float
+    timestamp: float = field(default_factory=time.time)
+
+
+# ============================================================================
+# Profiler Class
+# ============================================================================
+
+class Profiler:
+    """
+    Centralized profiler for performance monitoring.
+    
+    Thread-safe singleton pattern for global access.
+    """
+    
+    _instance: Optional['Profiler'] = None
+    _lock = threading.Lock()
+    
+    # Class-level storage
+    _timings: List[TimingRecord] = []
+    _imports: List[ImportRecord] = []
+    _flow: List[FlowRecord] = []
+    _enabled: bool = False
+    _flow_step: int = 0
+    _files_accessed: Dict[str, int] = {}
+    
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    @classmethod
+    def enable(cls) -> None:
+        """Enable profiling."""
+        cls._enabled = True
+    
+    @classmethod
+    def disable(cls) -> None:
+        """Disable profiling."""
+        cls._enabled = False
+    
+    @classmethod
+    def is_enabled(cls) -> bool:
+        """Check if profiling is enabled."""
+        return cls._enabled or os.environ.get('PRAISONAI_PROFILE', '').lower() in ('1', 'true', 'yes')
+    
+    @classmethod
+    def clear(cls) -> None:
+        """Clear all profiling data."""
+        with cls._lock:
+            cls._timings.clear()
+            cls._imports.clear()
+            cls._flow.clear()
+            cls._flow_step = 0
+            cls._files_accessed.clear()
+    
+    @classmethod
+    def record_timing(cls, name: str, duration_ms: float, category: str = "function", 
+                      file: str = "", line: int = 0) -> None:
+        """Record a timing measurement."""
+        if not cls.is_enabled():
+            return
+        
+        with cls._lock:
+            cls._timings.append(TimingRecord(
+                name=name,
+                duration_ms=duration_ms,
+                category=category,
+                file=file,
+                line=line
+            ))
+            
+            # Track file access
+            if file:
+                cls._files_accessed[file] = cls._files_accessed.get(file, 0) + 1
+    
+    @classmethod
+    def record_import(cls, module: str, duration_ms: float, parent: str = "") -> None:
+        """Record an import timing."""
+        if not cls.is_enabled():
+            return
+        
+        with cls._lock:
+            cls._imports.append(ImportRecord(
+                module=module,
+                duration_ms=duration_ms,
+                parent=parent
+            ))
+    
+    @classmethod
+    def record_flow(cls, name: str, duration_ms: float, file: str = "", line: int = 0) -> None:
+        """Record a flow step."""
+        if not cls.is_enabled():
+            return
+        
+        with cls._lock:
+            cls._flow_step += 1
+            cls._flow.append(FlowRecord(
+                step=cls._flow_step,
+                name=name,
+                file=file,
+                line=line,
+                duration_ms=duration_ms
+            ))
+    
+    @classmethod
+    @contextmanager
+    def block(cls, name: str, category: str = "block"):
+        """Context manager for profiling a block of code."""
+        start = time.time()
+        frame = sys._getframe(2) if hasattr(sys, '_getframe') else None
+        file = frame.f_code.co_filename if frame else ""
+        line = frame.f_lineno if frame else 0
+        
+        try:
+            yield
+        finally:
+            duration_ms = (time.time() - start) * 1000
+            cls.record_timing(name, duration_ms, category, file, line)
+            cls.record_flow(name, duration_ms, file, line)
+    
+    @classmethod
+    def get_timings(cls, category: Optional[str] = None) -> List[TimingRecord]:
+        """Get timing records, optionally filtered by category."""
+        with cls._lock:
+            if category:
+                return [t for t in cls._timings if t.category == category]
+            return cls._timings.copy()
+    
+    @classmethod
+    def get_imports(cls, min_duration_ms: float = 0) -> List[ImportRecord]:
+        """Get import records, optionally filtered by minimum duration."""
+        with cls._lock:
+            if min_duration_ms > 0:
+                return [i for i in cls._imports if i.duration_ms >= min_duration_ms]
+            return cls._imports.copy()
+    
+    @classmethod
+    def get_flow(cls) -> List[FlowRecord]:
+        """Get flow records."""
+        with cls._lock:
+            return cls._flow.copy()
+    
+    @classmethod
+    def get_files_accessed(cls) -> Dict[str, int]:
+        """Get files accessed with counts."""
+        with cls._lock:
+            return cls._files_accessed.copy()
+    
+    @classmethod
+    def get_summary(cls) -> Dict[str, Any]:
+        """Get profiling summary."""
+        with cls._lock:
+            total_time = sum(t.duration_ms for t in cls._timings)
+            import_time = sum(i.duration_ms for i in cls._imports)
+            
+            # Group by category
+            by_category: Dict[str, float] = {}
+            for t in cls._timings:
+                by_category[t.category] = by_category.get(t.category, 0) + t.duration_ms
+            
+            # Top slowest
+            slowest = sorted(cls._timings, key=lambda x: x.duration_ms, reverse=True)[:10]
+            slowest_imports = sorted(cls._imports, key=lambda x: x.duration_ms, reverse=True)[:10]
+            
+            return {
+                'total_time_ms': total_time,
+                'import_time_ms': import_time,
+                'timing_count': len(cls._timings),
+                'import_count': len(cls._imports),
+                'flow_steps': len(cls._flow),
+                'files_accessed': len(cls._files_accessed),
+                'by_category': by_category,
+                'slowest_operations': [(s.name, s.duration_ms) for s in slowest],
+                'slowest_imports': [(s.module, s.duration_ms) for s in slowest_imports],
+            }
+    
+    @classmethod
+    def report(cls, output: str = "console") -> str:
+        """Generate and output profiling report."""
+        summary = cls.get_summary()
+        
+        lines = [
+            "=" * 60,
+            "PraisonAI Profiling Report",
+            "=" * 60,
+            "",
+            f"Total Time: {summary['total_time_ms']:.2f}ms",
+            f"Import Time: {summary['import_time_ms']:.2f}ms",
+            f"Timing Records: {summary['timing_count']}",
+            f"Import Records: {summary['import_count']}",
+            f"Flow Steps: {summary['flow_steps']}",
+            f"Files Accessed: {summary['files_accessed']}",
+            "",
+            "By Category:",
+        ]
+        
+        for cat, time_ms in summary['by_category'].items():
+            lines.append(f"  {cat}: {time_ms:.2f}ms")
+        
+        lines.extend([
+            "",
+            "Slowest Operations:",
+        ])
+        for name, time_ms in summary['slowest_operations']:
+            lines.append(f"  {name}: {time_ms:.2f}ms")
+        
+        lines.extend([
+            "",
+            "Slowest Imports:",
+        ])
+        for module, time_ms in summary['slowest_imports']:
+            lines.append(f"  {module}: {time_ms:.2f}ms")
+        
+        lines.append("=" * 60)
+        
+        report_text = "\n".join(lines)
+        
+        if output == "console":
+            print(report_text)
+        
+        return report_text
+
+
+# ============================================================================
+# Decorators
+# ============================================================================
+
+def profile(func: Optional[Callable] = None, *, category: str = "function"):
+    """
+    Decorator to profile a function.
+    
+    Usage:
+        @profile
+        def my_function():
+            pass
+        
+        @profile(category="api")
+        def api_call():
+            pass
+    """
+    def decorator(fn: Callable) -> Callable:
+        @functools.wraps(fn)
+        def wrapper(*args, **kwargs):
+            if not Profiler.is_enabled():
+                return fn(*args, **kwargs)
+            
+            start = time.time()
+            try:
+                return fn(*args, **kwargs)
+            finally:
+                duration_ms = (time.time() - start) * 1000
+                file = fn.__code__.co_filename if hasattr(fn, '__code__') else ""
+                line = fn.__code__.co_firstlineno if hasattr(fn, '__code__') else 0
+                Profiler.record_timing(fn.__name__, duration_ms, category, file, line)
+                Profiler.record_flow(fn.__name__, duration_ms, file, line)
+        
+        return wrapper
+    
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+def profile_async(func: Optional[Callable] = None, *, category: str = "async"):
+    """
+    Decorator to profile an async function.
+    """
+    def decorator(fn: Callable) -> Callable:
+        @functools.wraps(fn)
+        async def wrapper(*args, **kwargs):
+            if not Profiler.is_enabled():
+                return await fn(*args, **kwargs)
+            
+            start = time.time()
+            try:
+                return await fn(*args, **kwargs)
+            finally:
+                duration_ms = (time.time() - start) * 1000
+                file = fn.__code__.co_filename if hasattr(fn, '__code__') else ""
+                line = fn.__code__.co_firstlineno if hasattr(fn, '__code__') else 0
+                Profiler.record_timing(fn.__name__, duration_ms, category, file, line)
+                Profiler.record_flow(fn.__name__, duration_ms, file, line)
+        
+        return wrapper
+    
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+# ============================================================================
+# Import Profiling
+# ============================================================================
+
+class ImportProfiler:
+    """
+    Context manager to profile imports.
+    
+    Usage:
+        with profile_imports() as profiler:
+            import heavy_module
+        
+        print(profiler.get_imports())
+    """
+    
+    def __init__(self):
+        self._original_import = None
+        self._imports: List[ImportRecord] = []
+    
+    def __enter__(self):
+        import builtins
+        self._original_import = builtins.__import__
+        
+        def profiled_import(name, globals=None, locals=None, fromlist=(), level=0):
+            start = time.time()
+            try:
+                return self._original_import(name, globals, locals, fromlist, level)
+            finally:
+                duration_ms = (time.time() - start) * 1000
+                if duration_ms > 1:  # Only record imports > 1ms
+                    record = ImportRecord(module=name, duration_ms=duration_ms)
+                    self._imports.append(record)
+                    Profiler.record_import(name, duration_ms)
+        
+        builtins.__import__ = profiled_import
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        import builtins
+        builtins.__import__ = self._original_import
+        return False
+    
+    def get_imports(self, min_duration_ms: float = 0) -> List[ImportRecord]:
+        """Get recorded imports."""
+        if min_duration_ms > 0:
+            return [i for i in self._imports if i.duration_ms >= min_duration_ms]
+        return self._imports.copy()
+    
+    def get_slowest(self, n: int = 10) -> List[ImportRecord]:
+        """Get N slowest imports."""
+        return sorted(self._imports, key=lambda x: x.duration_ms, reverse=True)[:n]
+
+
+def profile_imports():
+    """Create an import profiler context manager."""
+    return ImportProfiler()
+
+
+# ============================================================================
+# Quick Profiling Functions
+# ============================================================================
+
+def time_import(module_name: str) -> float:
+    """
+    Time how long it takes to import a module.
+    
+    Returns duration in milliseconds.
+    """
+    start = time.time()
+    __import__(module_name)
+    return (time.time() - start) * 1000
+
+
+def check_module_available(module_name: str) -> bool:
+    """
+    Check if a module is available without importing it.
+    
+    Uses importlib.util.find_spec which is fast.
+    """
+    import importlib.util
+    return importlib.util.find_spec(module_name) is not None
+
+
+# ============================================================================
+# Exports
+# ============================================================================
+
+__all__ = [
+    'Profiler',
+    'profile',
+    'profile_async',
+    'profile_imports',
+    'ImportProfiler',
+    'time_import',
+    'check_module_available',
+    'TimingRecord',
+    'ImportRecord',
+    'FlowRecord',
+]

src/praisonai/praisonai/scheduler.py

@@ -1,13 +1,31 @@
-import re
+"""
+DEPRECATED: This module is deprecated. Use praisonai.scheduler instead.
+
+This file is kept for backward compatibility only.
+All new code should import from praisonai.scheduler.
+"""
+
+import warnings
+import logging
 import threading
 import time
-import logging
-from datetime import datetime, timedelta
-from typing import Union, Optional, Callable, Dict, Any
+from typing import Optional, Dict, Any
 from abc import ABC, abstractmethod
 
 logger = logging.getLogger(__name__)
 
+# Issue deprecation warning
+warnings.warn(
+    "praisonai.scheduler module (root level) is deprecated. "
+    "Use 'from praisonai.scheduler import ...' instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+# Import from new scheduler module for backward compatibility
+from .scheduler.base import ScheduleParser
+
+# Keep old classes for backward compatibility
 class DeployerInterface(ABC):
     """Abstract interface for deployers to ensure provider compatibility."""
     
@@ -32,45 +50,6 @@ class CloudDeployerAdapter(DeployerInterface):
             logger.error(f"Deployment failed: {e}")
             return False
 
-class ScheduleParser:
-    """Parse schedule expressions into intervals."""
-    
-    @staticmethod
-    def parse(schedule_expr: str) -> int:
-        """
-        Parse schedule expression and return interval in seconds.
-        
-        Supported formats:
-        - "daily" -> 86400 seconds
-        - "hourly" -> 3600 seconds
-        - "*/30m" -> 1800 seconds (every 30 minutes)
-        - "*/6h" -> 21600 seconds (every 6 hours)
-        - "60" -> 60 seconds (plain number)
-        """
-        schedule_expr = schedule_expr.strip().lower()
-        
-        if schedule_expr == "daily":
-            return 86400
-        elif schedule_expr == "hourly":
-            return 3600
-        elif schedule_expr.isdigit():
-            return int(schedule_expr)
-        elif schedule_expr.startswith("*/"):
-            # Handle */30m, */6h patterns
-            interval_part = schedule_expr[2:]
-            if interval_part.endswith("m"):
-                minutes = int(interval_part[:-1])
-                return minutes * 60
-            elif interval_part.endswith("h"):
-                hours = int(interval_part[:-1])
-                return hours * 3600
-            elif interval_part.endswith("s"):
-                return int(interval_part[:-1])
-            else:
-                return int(interval_part)
-        else:
-            raise ValueError(f"Unsupported schedule format: {schedule_expr}")
-
 class DeploymentScheduler:
     """
     Minimal deployment scheduler with provider-agnostic design.

src/praisonai/praisonai/scheduler/README.md

@@ -0,0 +1,274 @@
+# PraisonAI Scheduler - 24/7 Agent Scheduling
+
+Complete implementation of 24/7 agent scheduling for PraisonAI, enabling autonomous agent operations at regular intervals.
+
+## ✅ Implementation Status
+
+### **Completed Features**
+
+#### 1. **Core Scheduler Module** (`praisonai/scheduler/`)
+- ✅ `base.py` - ScheduleParser, ExecutorInterface, PraisonAgentExecutor
+- ✅ `agent_scheduler.py` - AgentScheduler with full 24/7 capabilities
+- ✅ `__init__.py` - Clean module exports with lazy loading
+
+#### 2. **Schedule Parser**
+Supports multiple schedule formats:
+- `"hourly"` → Every hour (3600s)
+- `"daily"` → Every day (86400s)
+- `"*/30m"` → Every 30 minutes
+- `"*/6h"` → Every 6 hours
+- `"*/5s"` → Every 5 seconds
+- `"3600"` → Custom seconds (3600s)
+
+#### 3. **AgentScheduler Features**
+- ✅ Thread-based execution (daemon threads)
+- ✅ Configurable intervals
+- ✅ Retry logic with exponential backoff (30s, 60s, 90s...)
+- ✅ Success/failure callbacks
+- ✅ Execution statistics tracking
+- ✅ Graceful shutdown with timeout
+- ✅ `run_immediately` option
+- ✅ Thread-safe operation
+
+#### 4. **Testing**
+- ✅ 53 unit tests (100% passing)
+- ✅ 18 tests for base components
+- ✅ 35 tests for AgentScheduler
+- ✅ Real-world testing with live API calls
+- ✅ Verified with OpenAI API and search tools
+
+#### 5. **Backward Compatibility**
+- ✅ Old `scheduler.py` imports from new module
+- ✅ Deprecation warnings added
+- ✅ Existing code continues to work
+
+## 🚀 Quick Start
+
+### Basic Usage
+
+```python
+from praisonaiagents import Agent
+from praisonai.scheduler import AgentScheduler
+
+# Create your agent
+agent = Agent(
+    name="NewsChecker",
+    instructions="Check latest AI news and summarize",
+    tools=[search_tool]
+)
+
+# Create scheduler
+scheduler = AgentScheduler(
+    agent=agent,
+    task="Search for latest AI news and provide top 3 stories"
+)
+
+# Start scheduling (runs every hour)
+scheduler.start(
+    schedule_expr="hourly",
+    max_retries=3,
+    run_immediately=True
+)
+
+# Keep running until stopped
+try:
+    while scheduler.is_running:
+        import time
+        time.sleep(1)
+except KeyboardInterrupt:
+    scheduler.stop()
+    print(scheduler.get_stats())
+```
+
+### With Callbacks
+
+```python
+def on_success(result):
+    print(f"✅ Success: {result}")
+
+def on_failure(error):
+    print(f"❌ Failed: {error}")
+
+scheduler = AgentScheduler(
+    agent=agent,
+    task="Your task",
+    on_success=on_success,
+    on_failure=on_failure
+)
+
+scheduler.start("*/30m")  # Every 30 minutes
+```
+
+### Schedule Formats
+
+```python
+# Predefined intervals
+scheduler.start("hourly")    # Every hour
+scheduler.start("daily")     # Every 24 hours
+
+# Custom intervals
+scheduler.start("*/30m")     # Every 30 minutes
+scheduler.start("*/6h")      # Every 6 hours
+scheduler.start("*/5s")      # Every 5 seconds
+
+# Seconds
+scheduler.start("3600")      # Every 3600 seconds (1 hour)
+```
+
+## 📊 Statistics Tracking
+
+```python
+stats = scheduler.get_stats()
+# Returns:
+# {
+#     "is_running": True/False,
+#     "total_executions": 10,
+#     "successful_executions": 9,
+#     "failed_executions": 1,
+#     "success_rate": 90.0
+# }
+```
+
+## 🔧 Advanced Features
+
+### Retry Logic
+- Automatic retry on failure
+- Exponential backoff (30s, 60s, 90s...)
+- Configurable max retries
+
+```python
+scheduler.start(
+    schedule_expr="hourly",
+    max_retries=5  # Retry up to 5 times
+)
+```
+
+### Immediate Execution
+```python
+scheduler.start(
+    schedule_expr="hourly",
+    run_immediately=True  # Run once before starting schedule
+)
+```
+
+### One-Time Execution
+```python
+result = scheduler.execute_once()  # Execute immediately, no scheduling
+```
+
+### Graceful Shutdown
+```python
+scheduler.stop()  # Waits up to 10 seconds for current execution to finish
+```
+
+## 📁 File Structure
+
+```
+praisonai/scheduler/
+├── __init__.py              # Module exports
+├── base.py                  # ScheduleParser, ExecutorInterface
+├── agent_scheduler.py       # AgentScheduler implementation
+└── README.md               # This file
+
+tests/unit/scheduler/
+├── __init__.py
+├── test_base.py            # 18 tests for base components
+└── test_agent_scheduler.py # 35 tests for AgentScheduler
+```
+
+## ✅ Test Results
+
+```bash
+$ pytest tests/unit/scheduler/ -v
+============================= test session starts ==============================
+collected 53 items
+
+tests/unit/scheduler/test_agent_scheduler.py::... PASSED [100%]
+tests/unit/scheduler/test_base.py::... PASSED [100%]
+
+============================== 53 passed in 0.54s ===============================
+```
+
+## 🎯 Real-World Example
+
+See `examples/python/scheduled_agents/news_checker_live.py` for a complete working example that:
+- Checks AI news every 2 minutes (configurable to hourly)
+- Uses real OpenAI API
+- Uses DuckDuckGo search
+- Displays results with callbacks
+- Tracks statistics
+- Handles Ctrl+C gracefully
+
+## 🔄 Migration from Old Scheduler
+
+Old code continues to work with deprecation warning:
+
+```python
+# Old (still works)
+from praisonai.scheduler import ScheduleParser
+
+# New (recommended)
+from praisonai.scheduler import ScheduleParser
+```
+
+## 📝 API Reference
+
+### AgentScheduler
+
+**Constructor:**
+```python
+AgentScheduler(
+    agent,                    # PraisonAI Agent instance
+    task: str,               # Task description
+    config: Optional[Dict] = None,
+    on_success: Optional[Callable] = None,
+    on_failure: Optional[Callable] = None
+)
+```
+
+**Methods:**
+- `start(schedule_expr, max_retries=3, run_immediately=False) -> bool`
+- `stop() -> bool`
+- `execute_once() -> Any`
+- `get_stats() -> Dict`
+
+### ScheduleParser
+
+**Methods:**
+- `parse(schedule_expr: str) -> int` - Returns interval in seconds
+
+### ExecutorInterface
+
+**Abstract Methods:**
+- `execute(task: str) -> Any` - Must be implemented by subclasses
+
+## 🎉 Success Metrics
+
+- ✅ 53/53 tests passing (100%)
+- ✅ Real-world testing successful
+- ✅ Verified with live API calls
+- ✅ Thread-safe operation confirmed
+- ✅ Memory stable over multiple executions
+- ✅ Graceful shutdown working
+- ✅ Backward compatibility maintained
+
+## 🚀 Production Ready
+
+The scheduler is **production-ready** and can be used for:
+- 24/7 news monitoring
+- Periodic data collection
+- Scheduled report generation
+- Continuous monitoring tasks
+- Automated agent workflows
+
+## 📚 Examples
+
+See `examples/python/scheduled_agents/` for:
+- `simple_test.py` - Basic functionality test
+- `news_checker_live.py` - Real-world news checking agent
+- `news_checker_agent.py` - Full-featured example with documentation
+
+## 🔗 Related
+
+- Main PraisonAI docs: [docs.praison.ai](https://docs.praison.ai)
+- PraisonAI Agents: [github.com/MervinPraison/PraisonAI](https://github.com/MervinPraison/PraisonAI)

src/praisonai/praisonai/scheduler/__init__.py

@@ -0,0 +1,36 @@
+"""
+PraisonAI Scheduler Module
+
+This module provides scheduling capabilities for running agents and deployments
+at regular intervals, enabling 24/7 autonomous operations.
+
+Components:
+- ScheduleParser: Parse schedule expressions (hourly, daily, */30m, etc.)
+- ExecutorInterface: Abstract interface for executors
+- AgentScheduler: Schedule agent execution at regular intervals
+- DeploymentScheduler: Schedule deployment operations
+"""
+
+from .base import ScheduleParser, ExecutorInterface, PraisonAgentExecutor
+
+__all__ = [
+    'ScheduleParser',
+    'ExecutorInterface',
+    'PraisonAgentExecutor',
+]
+
+# Lazy imports for modules that will be created later
+def __getattr__(name):
+    if name == 'AgentScheduler':
+        from .agent_scheduler import AgentScheduler
+        return AgentScheduler
+    elif name == 'create_agent_scheduler':
+        from .agent_scheduler import create_agent_scheduler
+        return create_agent_scheduler
+    elif name == 'DeploymentScheduler':
+        from .deployment_scheduler import DeploymentScheduler
+        return DeploymentScheduler
+    elif name == 'create_deployment_scheduler':
+        from .deployment_scheduler import create_deployment_scheduler
+        return create_deployment_scheduler
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

src/praisonai/praisonai/scheduler/agent_scheduler.py

@@ -0,0 +1,348 @@
+"""
+Agent Scheduler for PraisonAI - Run agents periodically 24/7.
+
+This module provides scheduling capabilities for running PraisonAI agents
+at regular intervals, enabling 24/7 autonomous agent operations.
+"""
+
+import threading
+import time
+import logging
+from datetime import datetime
+from typing import Optional, Dict, Any, Callable
+
+from .base import ScheduleParser, PraisonAgentExecutor
+
+logger = logging.getLogger(__name__)
+
+
+class AgentScheduler:
+    """
+    Scheduler for running PraisonAI agents periodically.
+    
+    Features:
+    - Interval-based scheduling (hourly, daily, custom)
+    - Thread-safe operation
+    - Automatic retry on failure
+    - Execution logging and monitoring
+    - Graceful shutdown
+    
+    Example:
+        scheduler = AgentScheduler(agent, task="Check news")
+        scheduler.start(schedule_expr="hourly", max_retries=3)
+        # Agent runs every hour automatically
+        scheduler.stop()  # Stop when needed
+    """
+    
+    def __init__(
+        self,
+        agent,
+        task: str,
+        config: Optional[Dict[str, Any]] = None,
+        on_success: Optional[Callable] = None,
+        on_failure: Optional[Callable] = None
+    ):
+        """
+        Initialize agent scheduler.
+        
+        Args:
+            agent: PraisonAI Agent instance
+            task: Task description to execute
+            config: Optional configuration dict
+            on_success: Callback function on successful execution
+            on_failure: Callback function on failed execution
+        """
+        self.agent = agent
+        self.task = task
+        self.config = config or {}
+        self.on_success = on_success
+        self.on_failure = on_failure
+        
+        self.is_running = False
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._executor = PraisonAgentExecutor(agent)
+        self._execution_count = 0
+        self._success_count = 0
+        self._failure_count = 0
+        
+    def start(
+        self,
+        schedule_expr: str,
+        max_retries: int = 3,
+        run_immediately: bool = False
+    ) -> bool:
+        """
+        Start scheduled agent execution.
+        
+        Args:
+            schedule_expr: Schedule expression (e.g., "hourly", "*/6h", "3600")
+            max_retries: Maximum retry attempts on failure
+            run_immediately: If True, run agent immediately before starting schedule
+            
+        Returns:
+            True if scheduler started successfully
+        """
+        if self.is_running:
+            logger.warning("Scheduler is already running")
+            return False
+            
+        try:
+            interval = ScheduleParser.parse(schedule_expr)
+            self.is_running = True
+            self._stop_event.clear()
+            
+            logger.info(f"Starting agent scheduler: {getattr(self.agent, 'name', 'Agent')}")
+            logger.info(f"Task: {self.task}")
+            logger.info(f"Schedule: {schedule_expr} ({interval}s interval)")
+            logger.info(f"Max retries: {max_retries}")
+            
+            # Run immediately if requested
+            if run_immediately:
+                logger.info("Running agent immediately before starting schedule...")
+                self._execute_with_retry(max_retries)
+            
+            self._thread = threading.Thread(
+                target=self._run_schedule,
+                args=(interval, max_retries),
+                daemon=True
+            )
+            self._thread.start()
+            
+            logger.info("Agent scheduler started successfully")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to start scheduler: {e}")
+            self.is_running = False
+            return False
+    
+    def stop(self) -> bool:
+        """
+        Stop the scheduler gracefully.
+        
+        Returns:
+            True if stopped successfully
+        """
+        if not self.is_running:
+            logger.info("Scheduler is not running")
+            return True
+            
+        logger.info("Stopping agent scheduler...")
+        self._stop_event.set()
+        
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=10)
+            
+        self.is_running = False
+        logger.info("Agent scheduler stopped")
+        logger.info(f"Execution stats - Total: {self._execution_count}, Success: {self._success_count}, Failed: {self._failure_count}")
+        return True
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """
+        Get execution statistics.
+        
+        Returns:
+            Dictionary with execution stats
+        """
+        return {
+            "is_running": self.is_running,
+            "total_executions": self._execution_count,
+            "successful_executions": self._success_count,
+            "failed_executions": self._failure_count,
+            "success_rate": (self._success_count / self._execution_count * 100) if self._execution_count > 0 else 0
+        }
+    
+    def _run_schedule(self, interval: int, max_retries: int):
+        """Internal method to run scheduled agent executions."""
+        while not self._stop_event.is_set():
+            logger.info(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Starting scheduled agent execution")
+            
+            self._execute_with_retry(max_retries)
+            
+            # Wait for next scheduled time
+            logger.info(f"Next execution in {interval} seconds ({interval/3600:.1f} hours)")
+            self._stop_event.wait(interval)
+    
+    def _execute_with_retry(self, max_retries: int):
+        """Execute agent with retry logic."""
+        self._execution_count += 1
+        success = False
+        result = None
+        
+        for attempt in range(max_retries):
+            try:
+                logger.info(f"Attempt {attempt + 1}/{max_retries}")
+                result = self._executor.execute(self.task)
+                
+                logger.info(f"Agent execution successful on attempt {attempt + 1}")
+                logger.info(f"Result: {result}")
+                
+                self._success_count += 1
+                success = True
+                
+                if self.on_success:
+                    try:
+                        self.on_success(result)
+                    except Exception as e:
+                        logger.error(f"Callback error in on_success: {e}")
+                    
+                break
+                
+            except Exception as e:
+                logger.error(f"Agent execution failed on attempt {attempt + 1}: {e}")
+                
+                if attempt < max_retries - 1:
+                    wait_time = 30 * (attempt + 1)  # Exponential backoff
+                    logger.info(f"Waiting {wait_time}s before retry...")
+                    time.sleep(wait_time)
+        
+        if not success:
+            self._failure_count += 1
+            logger.error(f"Agent execution failed after {max_retries} attempts")
+            
+            if self.on_failure:
+                try:
+                    self.on_failure(f"Failed after {max_retries} attempts")
+                except Exception as e:
+                    logger.error(f"Callback error in on_failure: {e}")
+    
+    def execute_once(self) -> Any:
+        """
+        Execute agent immediately (one-time execution).
+        
+        Returns:
+            Agent execution result
+        """
+        logger.info("Executing agent once")
+        try:
+            result = self._executor.execute(self.task)
+            logger.info(f"One-time execution successful: {result}")
+            
+            if self.on_success:
+                try:
+                    self.on_success(result)
+                except Exception as e:
+                    logger.error(f"Callback error in on_success: {e}")
+            
+            return result
+        except Exception as e:
+            logger.error(f"One-time execution failed: {e}")
+            raise
+    
+    @classmethod
+    def from_yaml(
+        cls,
+        yaml_path: str,
+        interval_override: Optional[str] = None,
+        max_retries_override: Optional[int] = None,
+        on_success: Optional[Callable] = None,
+        on_failure: Optional[Callable] = None
+    ) -> 'AgentScheduler':
+        """
+        Create AgentScheduler from agents.yaml file.
+        
+        Args:
+            yaml_path: Path to agents.yaml file
+            interval_override: Override schedule interval from YAML
+            max_retries_override: Override max_retries from YAML
+            on_success: Callback function on successful execution
+            on_failure: Callback function on failed execution
+            
+        Returns:
+            Configured AgentScheduler instance
+            
+        Example:
+            scheduler = AgentScheduler.from_yaml("agents.yaml")
+            scheduler.start()
+            
+        Example agents.yaml:
+            framework: praisonai
+            
+            agents:
+              - name: "AI News Monitor"
+                role: "News Analyst"
+                instructions: "Search and summarize AI news"
+                tools:
+                  - search_tool
+            
+            task: "Search for latest AI news"
+            
+            schedule:
+              interval: "hourly"
+              max_retries: 3
+              run_immediately: true
+        """
+        from .yaml_loader import load_agent_yaml_with_schedule, create_agent_from_config
+        
+        # Load configuration from YAML
+        agent_config, schedule_config = load_agent_yaml_with_schedule(yaml_path)
+        
+        # Create agent from config
+        agent = create_agent_from_config(agent_config)
+        
+        # Get task
+        task = agent_config.get('task', '')
+        if not task:
+            raise ValueError("No task specified in YAML file")
+        
+        # Create scheduler
+        scheduler = cls(
+            agent=agent,
+            task=task,
+            config=agent_config,
+            on_success=on_success,
+            on_failure=on_failure
+        )
+        
+        # Store schedule config for auto-start
+        scheduler._yaml_schedule_config = schedule_config
+        scheduler._interval_override = interval_override
+        scheduler._max_retries_override = max_retries_override
+        
+        return scheduler
+    
+    def start_from_yaml_config(self) -> bool:
+        """
+        Start scheduler using configuration from YAML file.
+        
+        Must be called after from_yaml() class method.
+        
+        Returns:
+            True if scheduler started successfully
+        """
+        if not hasattr(self, '_yaml_schedule_config'):
+            raise RuntimeError("start_from_yaml_config() can only be called after from_yaml()")
+        
+        schedule_config = self._yaml_schedule_config
+        
+        # Use overrides if provided, otherwise use YAML config
+        interval = self._interval_override or schedule_config.get('interval', 'hourly')
+        max_retries = self._max_retries_override or schedule_config.get('max_retries', 3)
+        run_immediately = schedule_config.get('run_immediately', False)
+        
+        return self.start(
+            schedule_expr=interval,
+            max_retries=max_retries,
+            run_immediately=run_immediately
+        )
+
+
+def create_agent_scheduler(
+    agent,
+    task: str,
+    config: Optional[Dict[str, Any]] = None
+) -> AgentScheduler:
+    """
+    Factory function to create agent scheduler.
+    
+    Args:
+        agent: PraisonAI Agent instance
+        task: Task description
+        config: Optional configuration
+        
+    Returns:
+        Configured AgentScheduler instance
+    """
+    return AgentScheduler(agent, task, config)

src/praisonai/praisonai/scheduler/base.py

@@ -0,0 +1,124 @@
+"""
+Base components for PraisonAI Scheduler.
+
+This module provides shared functionality for all schedulers:
+- ScheduleParser: Parse schedule expressions into intervals
+- ExecutorInterface: Abstract interface for executors
+- PraisonAgentExecutor: Executor for PraisonAI agents
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class ScheduleParser:
+    """Parse schedule expressions into intervals in seconds."""
+    
+    @staticmethod
+    def parse(schedule_expr: str) -> int:
+        """
+        Parse schedule expression and return interval in seconds.
+        
+        Supported formats:
+        - "daily" -> 86400 seconds
+        - "hourly" -> 3600 seconds
+        - "*/30m" -> 1800 seconds (every 30 minutes)
+        - "*/6h" -> 21600 seconds (every 6 hours)
+        - "*/30s" -> 30 seconds (every 30 seconds)
+        - "3600" -> 3600 seconds (plain number)
+        
+        Args:
+            schedule_expr: Schedule expression string
+            
+        Returns:
+            Interval in seconds
+            
+        Raises:
+            ValueError: If schedule format is not supported
+            
+        Examples:
+            >>> ScheduleParser.parse("hourly")
+            3600
+            >>> ScheduleParser.parse("*/30m")
+            1800
+            >>> ScheduleParser.parse("daily")
+            86400
+        """
+        schedule_expr = schedule_expr.strip().lower()
+        
+        if schedule_expr == "daily":
+            return 86400
+        elif schedule_expr == "hourly":
+            return 3600
+        elif schedule_expr.isdigit():
+            return int(schedule_expr)
+        elif schedule_expr.startswith("*/"):
+            interval_part = schedule_expr[2:]
+            if interval_part.endswith("m"):
+                minutes = int(interval_part[:-1])
+                return minutes * 60
+            elif interval_part.endswith("h"):
+                hours = int(interval_part[:-1])
+                return hours * 3600
+            elif interval_part.endswith("s"):
+                return int(interval_part[:-1])
+            else:
+                return int(interval_part)
+        else:
+            raise ValueError(f"Unsupported schedule format: {schedule_expr}")
+
+
+class ExecutorInterface(ABC):
+    """Abstract interface for executors."""
+    
+    @abstractmethod
+    def execute(self, task: str) -> Any:
+        """
+        Execute a task.
+        
+        Args:
+            task: Task description or instruction
+            
+        Returns:
+            Execution result
+            
+        Raises:
+            Exception: If execution fails
+        """
+        pass
+
+
+class PraisonAgentExecutor(ExecutorInterface):
+    """Executor for PraisonAI agents."""
+    
+    def __init__(self, agent):
+        """
+        Initialize executor with a PraisonAI agent.
+        
+        Args:
+            agent: PraisonAI Agent instance (must have start() method)
+        """
+        self.agent = agent
+        
+    def execute(self, task: str) -> Any:
+        """
+        Execute the agent with given task.
+        
+        Args:
+            task: Task description for the agent
+            
+        Returns:
+            Agent execution result
+            
+        Raises:
+            Exception: If agent execution fails
+        """
+        try:
+            result = self.agent.start(task)
+            return result
+        except Exception as e:
+            logger.error(f"Agent execution failed: {e}")
+            raise

src/praisonai/praisonai/scheduler/yaml_loader.py

@@ -0,0 +1,197 @@
+"""
+YAML loader for agent scheduler configuration.
+
+Loads agent and schedule configuration from agents.yaml files.
+"""
+
+import yaml
+import logging
+from typing import Dict, Any, Tuple
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def load_agent_yaml_with_schedule(yaml_path: str) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    """
+    Load agents.yaml file and extract agent and schedule configuration.
+    
+    Args:
+        yaml_path: Path to agents.yaml file
+        
+    Returns:
+        Tuple of (agent_config, schedule_config)
+        
+    Raises:
+        FileNotFoundError: If YAML file doesn't exist
+        ValueError: If YAML is invalid or missing required fields
+        
+    Example YAML structure:
+        framework: praisonai
+        
+        agents:
+          - name: "AI News Monitor"
+            role: "News Analyst"
+            goal: "Monitor AI news"
+            instructions: "Search and summarize"
+            tools:
+              - search_tool
+            verbose: true
+        
+        task: "Search for latest AI news"
+        
+        schedule:
+          interval: "hourly"
+          max_retries: 3
+          run_immediately: true
+    """
+    yaml_path = Path(yaml_path)
+    
+    if not yaml_path.exists():
+        raise FileNotFoundError(f"YAML file not found: {yaml_path}")
+    
+    try:
+        with open(yaml_path, 'r') as f:
+            config = yaml.safe_load(f)
+    except yaml.YAMLError as e:
+        raise ValueError(f"Invalid YAML file: {e}")
+    
+    if not config:
+        raise ValueError("Empty YAML file")
+    
+    # Extract agent configuration
+    agent_config = {}
+    
+    # Get agents list (can be single agent or multiple)
+    agents = config.get('agents', [])
+    if not agents:
+        raise ValueError("No agents defined in YAML file")
+    
+    # Use first agent for scheduling (can be extended for multi-agent later)
+    if isinstance(agents, list):
+        agent_config = agents[0]
+    else:
+        agent_config = agents
+    
+    # Get task
+    task = config.get('task', '')
+    if not task:
+        # Try to get from agent's tasks
+        if 'tasks' in agent_config and agent_config['tasks']:
+            first_task = list(agent_config['tasks'].values())[0]
+            task = first_task.get('description', '')
+    
+    agent_config['task'] = task
+    
+    # Get framework (default to praisonai)
+    agent_config['framework'] = config.get('framework', 'praisonai')
+    
+    # Extract schedule configuration (optional)
+    schedule_config = config.get('schedule', {})
+    
+    # Set defaults for schedule if not provided
+    if not schedule_config:
+        schedule_config = {
+            'interval': 'hourly',
+            'max_retries': 3,
+            'run_immediately': False
+        }
+    else:
+        # Ensure required fields have defaults
+        schedule_config.setdefault('interval', 'hourly')
+        schedule_config.setdefault('max_retries', 3)
+        schedule_config.setdefault('run_immediately', False)
+    
+    logger.info(f"Loaded agent '{agent_config.get('name', 'Unknown')}' with schedule interval '{schedule_config['interval']}'")
+    
+    return agent_config, schedule_config
+
+
+def create_agent_from_config(agent_config: Dict[str, Any]) -> Any:
+    """
+    Create a PraisonAI Agent instance from configuration.
+    
+    Args:
+        agent_config: Agent configuration dictionary
+        
+    Returns:
+        Agent instance
+        
+    Raises:
+        ImportError: If praisonaiagents is not installed
+    """
+    try:
+        from praisonaiagents import Agent
+    except ImportError:
+        raise ImportError("praisonaiagents package is required. Install with: pip install praisonaiagents")
+    
+    # Extract agent parameters
+    name = agent_config.get('name', 'Scheduled Agent')
+    role = agent_config.get('role', '')
+    goal = agent_config.get('goal', '')
+    instructions = agent_config.get('instructions', agent_config.get('backstory', ''))
+    verbose = agent_config.get('verbose', False)
+    
+    # Handle tools
+    tools = []
+    tool_names = agent_config.get('tools', [])
+    
+    if tool_names:
+        # Try to import tools
+        for tool_name in tool_names:
+            try:
+                # Try common tool imports
+                if tool_name == 'search_tool' or tool_name == 'InternetSearchTool':
+                    try:
+                        from tools import search_tool
+                        tools.append(search_tool)
+                    except ImportError:
+                        logger.warning(f"Could not import {tool_name}, skipping")
+                # Add more tool imports as needed
+            except Exception as e:
+                logger.warning(f"Error loading tool {tool_name}: {e}")
+    
+    # Create agent
+    agent = Agent(
+        name=name,
+        role=role,
+        goal=goal,
+        instructions=instructions,
+        tools=tools,
+        verbose=verbose
+    )
+    
+    return agent
+
+
+def validate_schedule_config(schedule_config: Dict[str, Any]) -> None:
+    """
+    Validate schedule configuration.
+    
+    Args:
+        schedule_config: Schedule configuration dictionary
+        
+    Raises:
+        ValueError: If configuration is invalid
+    """
+    required_fields = ['interval']
+    for field in required_fields:
+        if field not in schedule_config:
+            raise ValueError(f"Missing required schedule field: {field}")
+    
+    # Validate interval format
+    interval = schedule_config['interval']
+    valid_intervals = ['hourly', 'daily']
+    
+    if interval not in valid_intervals:
+        # Check if it's a custom format (*/Nm, */Nh, */Ns, or plain number)
+        if not (interval.startswith('*/') or interval.isdigit()):
+            raise ValueError(
+                f"Invalid interval format: {interval}. "
+                f"Use 'hourly', 'daily', '*/30m', '*/6h', or seconds as number"
+            )
+    
+    # Validate max_retries
+    max_retries = schedule_config.get('max_retries', 3)
+    if not isinstance(max_retries, int) or max_retries < 0:
+        raise ValueError(f"max_retries must be a non-negative integer, got: {max_retries}")

src/praisonai/praisonai/version.py

@@ -1 +1 @@
-__version__ = "2.3.44"
+__version__ = "2.3.65"

src/praisonai/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.1.17",
+    "praisonaiagents>=0.1.21",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",

src/praisonai/tests/conftest.py

@@ -83,13 +83,19 @@ def setup_test_environment(request):
     # Real tests (marked with @pytest.mark.real) should use actual environment variables
     is_real_test = False
     
-    # Check if this test is marked as a real test
+    # Check if this test is marked as a real test or integration test
     if hasattr(request, 'node') and hasattr(request.node, 'iter_markers'):
         for marker in request.node.iter_markers():
-            if marker.name == 'real':
+            if marker.name in ('real', 'integration'):
                 is_real_test = True
                 break
     
+    # Also check if the test file is in the integration directory
+    if hasattr(request, 'fspath') and request.fspath:
+        test_path = str(request.fspath)
+        if '/integration/' in test_path or '\\integration\\' in test_path:
+            is_real_test = True
+    
     # Store original values to restore later
     original_values = {}
     

src/praisonai/tests/e2e/test_cli_features_e2e.py

@@ -0,0 +1,309 @@
+"""
+End-to-End Tests for CLI Features with Real API Keys.
+
+These tests require actual API keys to be set in environment variables:
+- OPENAI_API_KEY
+- ANTHROPIC_API_KEY (optional)
+- GEMINI_API_KEY (optional)
+
+Run with: pytest tests/e2e/test_cli_features_e2e.py -v --tb=short
+"""
+
+import pytest
+import os
+import time
+from unittest.mock import patch
+
+# Skip all tests if no API key is available
+pytestmark = pytest.mark.skipif(
+    not os.environ.get("OPENAI_API_KEY"),
+    reason="OPENAI_API_KEY not set"
+)
+
+
+class TestSlashCommandsE2E:
+    """End-to-end tests for slash commands."""
+    
+    def test_slash_command_handler_initialization(self):
+        """Test that slash command handler initializes correctly."""
+        from praisonai.cli.features import SlashCommandHandler
+        
+        handler = SlashCommandHandler(verbose=True)
+        assert handler.registry is not None
+        assert len(handler.registry.get_all()) > 0
+    
+    def test_help_command_execution(self):
+        """Test /help command execution."""
+        from praisonai.cli.features import SlashCommandHandler
+        
+        handler = SlashCommandHandler()
+        
+        with patch('rich.console.Console.print'):
+            result = handler.execute("/help")
+        
+        assert result is not None
+        assert result["type"] == "help"
+    
+    def test_cost_command_with_context(self):
+        """Test /cost command with session context."""
+        from praisonai.cli.features.slash_commands import (
+            SlashCommandHandler,
+            CommandContext
+        )
+        
+        handler = SlashCommandHandler()
+        ctx = CommandContext(
+            total_tokens=5000,
+            total_cost=0.015,
+            prompt_count=10,
+            session_start_time=time.time() - 300
+        )
+        handler.set_context(ctx)
+        
+        with patch('rich.console.Console.print'):
+            result = handler.execute("/cost")
+        
+        assert result["type"] == "stats"
+        assert result["tokens"] == 5000
+        assert result["cost"] == 0.015
+    
+    def test_command_completions(self):
+        """Test command auto-completion."""
+        from praisonai.cli.features import SlashCommandHandler
+        
+        handler = SlashCommandHandler()
+        
+        completions = handler.get_completions("/he")
+        assert "/help" in completions
+        
+        completions = handler.get_completions("/mo")
+        assert "/model" in completions
+
+
+class TestAutonomyModeE2E:
+    """End-to-end tests for autonomy modes."""
+    
+    def test_autonomy_mode_initialization(self):
+        """Test autonomy mode handler initialization."""
+        from praisonai.cli.features import AutonomyModeHandler
+        
+        handler = AutonomyModeHandler(verbose=True)
+        manager = handler.initialize(mode="suggest")
+        
+        assert manager is not None
+        assert handler.get_mode() == "suggest"
+    
+    def test_mode_transitions(self):
+        """Test transitioning between autonomy modes."""
+        from praisonai.cli.features import AutonomyModeHandler
+        
+        handler = AutonomyModeHandler()
+        handler.initialize(mode="suggest")
+        
+        # Test all mode transitions
+        for mode in ["suggest", "auto_edit", "full_auto"]:
+            handler.set_mode(mode)
+            assert handler.get_mode() == mode
+    
+    def test_approval_flow_suggest_mode(self):
+        """Test approval flow in suggest mode."""
+        from praisonai.cli.features.autonomy_mode import (
+            AutonomyModeHandler,
+            ActionRequest,
+            ActionType,
+            ApprovalResult
+        )
+        
+        # Mock approval callback
+        def mock_approval(action):
+            return ApprovalResult(approved=True)
+        
+        handler = AutonomyModeHandler()
+        handler.initialize(mode="suggest", approval_callback=mock_approval)
+        
+        # File read should be auto-approved
+        read_action = ActionRequest(ActionType.FILE_READ, "Read file")
+        result = handler.request_approval(read_action)
+        assert result.approved is True
+        
+        # File write should require approval (via callback)
+        write_action = ActionRequest(ActionType.FILE_WRITE, "Write file")
+        result = handler.request_approval(write_action)
+        assert result.approved is True
+    
+    def test_full_auto_mode(self):
+        """Test full auto mode approves everything."""
+        from praisonai.cli.features.autonomy_mode import (
+            AutonomyModeHandler,
+            ActionRequest,
+            ActionType
+        )
+        
+        handler = AutonomyModeHandler()
+        handler.initialize(mode="full_auto")
+        
+        # All actions should be auto-approved
+        actions = [
+            ActionRequest(ActionType.FILE_WRITE, "Write"),
+            ActionRequest(ActionType.SHELL_COMMAND, "Command"),
+            ActionRequest(ActionType.FILE_DELETE, "Delete"),
+        ]
+        
+        for action in actions:
+            result = handler.request_approval(action)
+            assert result.approved is True
+
+
+class TestCostTrackerE2E:
+    """End-to-end tests for cost tracking."""
+    
+    def test_cost_tracker_initialization(self):
+        """Test cost tracker initialization."""
+        from praisonai.cli.features import CostTrackerHandler
+        
+        handler = CostTrackerHandler(verbose=True)
+        tracker = handler.initialize(session_id="e2e-test")
+        
+        assert tracker is not None
+        assert tracker.session_id == "e2e-test"
+    
+    def test_track_multiple_requests(self):
+        """Test tracking multiple requests."""
+        from praisonai.cli.features import CostTrackerHandler
+        
+        handler = CostTrackerHandler()
+        handler.initialize()
+        
+        # Track several requests
+        models = ["gpt-4o", "gpt-4o-mini", "gpt-4o"]
+        for i, model in enumerate(models):
+            handler.track_request(
+                model=model,
+                input_tokens=1000 * (i + 1),
+                output_tokens=500 * (i + 1)
+            )
+        
+        assert handler.get_tokens() == 9000  # (1500 + 3000 + 4500)
+        assert handler.get_cost() > 0
+    
+    def test_cost_calculation_accuracy(self):
+        """Test cost calculation is accurate."""
+        from praisonai.cli.features.cost_tracker import CostTracker
+        
+        tracker = CostTracker()
+        
+        # gpt-4o: $2.50/1M input, $10.00/1M output
+        stats = tracker.track_request(
+            model="gpt-4o",
+            input_tokens=100_000,
+            output_tokens=50_000
+        )
+        
+        # Expected: (100K/1M * 2.50) + (50K/1M * 10.00) = 0.25 + 0.50 = 0.75
+        assert abs(stats.cost - 0.75) < 0.01
+    
+    def test_session_export(self):
+        """Test session data export."""
+        from praisonai.cli.features.cost_tracker import CostTracker
+        import json
+        
+        tracker = CostTracker(session_id="export-test")
+        tracker.track_request("gpt-4o", 1000, 500)
+        tracker.track_request("gpt-4o-mini", 2000, 1000)
+        
+        json_str = tracker.export_json()
+        data = json.loads(json_str)
+        
+        assert data["session"]["session_id"] == "export-test"
+        assert len(data["requests"]) == 2
+
+
+class TestIntegratedFeaturesE2E:
+    """End-to-end tests for integrated features."""
+    
+    def test_all_features_together(self):
+        """Test all features working together."""
+        from praisonai.cli.features import (
+            SlashCommandHandler,
+            AutonomyModeHandler,
+            CostTrackerHandler
+        )
+        from praisonai.cli.features.slash_commands import CommandContext
+        from praisonai.cli.features.autonomy_mode import (
+            ActionRequest,
+            ActionType,
+        )
+        
+        # Initialize all handlers
+        slash_handler = SlashCommandHandler()
+        autonomy_handler = AutonomyModeHandler()
+        cost_handler = CostTrackerHandler()
+        
+        # Set up autonomy mode
+        autonomy_handler.initialize(mode="auto_edit")
+        
+        # Initialize cost tracking
+        cost_handler.initialize(session_id="integrated-test")
+        
+        # Track some requests
+        cost_handler.track_request("gpt-4o", 1000, 500)
+        cost_handler.track_request("gpt-4o", 2000, 1000)
+        
+        # Set up slash command context with cost data
+        ctx = CommandContext(
+            total_tokens=cost_handler.get_tokens(),
+            total_cost=cost_handler.get_cost(),
+            prompt_count=2
+        )
+        slash_handler.set_context(ctx)
+        
+        # Execute cost command
+        with patch('rich.console.Console.print'):
+            result = slash_handler.execute("/cost")
+        
+        assert result["tokens"] == 4500
+        assert result["cost"] > 0
+        
+        # Test autonomy mode
+        write_action = ActionRequest(ActionType.FILE_WRITE, "Write file")
+        approval = autonomy_handler.request_approval(write_action)
+        assert approval.approved is True  # Auto-approved in auto_edit mode
+
+
+class TestRealAPIIntegration:
+    """Tests that use real API calls."""
+    
+    @pytest.mark.skipif(
+        not os.environ.get("OPENAI_API_KEY"),
+        reason="OPENAI_API_KEY required for this test"
+    )
+    def test_cost_tracking_with_real_agent(self):
+        """Test cost tracking with a real agent call."""
+        from praisonai.cli.features import CostTrackerHandler
+        
+        handler = CostTrackerHandler()
+        handler.initialize()
+        
+        # Simulate what would happen after an agent call
+        # In real usage, this would be called after agent.start()
+        handler.track_request(
+            model="gpt-4o-mini",
+            input_tokens=150,
+            output_tokens=50,
+            duration_ms=500.0
+        )
+        
+        summary = handler.get_summary()
+        
+        assert summary["total_requests"] == 1
+        assert summary["total_tokens"] == 200
+        assert summary["total_cost"] > 0
+        
+        # Print summary for verification
+        print("\nCost tracking test:")
+        print(f"  Tokens: {summary['total_tokens']}")
+        print(f"  Cost: ${summary['total_cost']:.6f}")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "--tb=short"])

src/praisonai/tests/integration/test_auto_generator_integration.py

@@ -14,9 +14,17 @@ import yaml
 # Add the source path for imports
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
 
-# Skip if no API key
-if not os.environ.get('OPENAI_API_KEY'):
-    pytest.skip("OPENAI_API_KEY not set", allow_module_level=True)
+# Skip if no API key or using test/invalid key
+# Valid OpenAI keys start with 'sk-' and are typically 51+ characters
+api_key = os.environ.get('OPENAI_API_KEY', '')
+is_test_key = (
+    not api_key or 
+    'test' in api_key.lower() or 
+    not api_key.startswith('sk-') or 
+    len(api_key) < 40
+)
+if is_test_key:
+    pytest.skip("OPENAI_API_KEY not set or using test/invalid key", allow_module_level=True)
 
 try:
     from praisonai.auto import AutoGenerator, WorkflowAutoGenerator

src/praisonai/tests/integration/test_cli_integrations.py

@@ -19,10 +19,15 @@ import sys
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
 
 
-# Skip all tests if no API keys are set
+# Skip all tests if no API keys are set or using test/invalid key
+# Valid OpenAI keys start with 'sk-' and are typically 51+ characters
+_api_key = os.environ.get("OPENAI_API_KEY", "")
 pytestmark = pytest.mark.skipif(
-    not os.environ.get("OPENAI_API_KEY"),
-    reason="OPENAI_API_KEY not set"
+    not _api_key or 
+    'test' in _api_key.lower() or 
+    not _api_key.startswith('sk-') or 
+    len(_api_key) < 40,
+    reason="OPENAI_API_KEY not set or using test/invalid key"
 )
 
 

src/praisonai/tests/integration/test_model_routing_real.py

@@ -0,0 +1,327 @@
+"""
+Real integration tests for Model Routing with actual API calls.
+
+Tests the RouterHandler with real LLM providers.
+Requires API keys: OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY
+"""
+
+import pytest
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+from praisonai.cli.features.router import RouterHandler
+
+
+class TestRouterHandlerReal:
+    """Real integration tests for RouterHandler."""
+    
+    def test_router_handler_initialization(self):
+        """Test RouterHandler initializes correctly."""
+        handler = RouterHandler(verbose=True)
+        
+        assert handler is not None
+        assert handler.model_router is not None
+        assert len(handler.model_router) > 0
+        print(f"✅ RouterHandler initialized with {len(handler.model_router)} default models")
+    
+    def test_complexity_analysis(self):
+        """Test complexity analysis for different prompts."""
+        handler = RouterHandler()
+        
+        # Simple prompts
+        simple_prompts = [
+            "What is 2+2?",
+            "Define photosynthesis",
+            "List the planets",
+        ]
+        
+        for prompt in simple_prompts:
+            complexity = handler.analyze_complexity(prompt)
+            print(f"  '{prompt[:30]}...' -> {complexity}")
+            assert complexity == 'simple', f"Expected 'simple' for: {prompt}"
+        
+        print("✅ Simple prompts correctly classified")
+        
+        # Complex prompts
+        complex_prompts = [
+            "Analyze and research the comprehensive impact of AI on healthcare systems globally",
+            "Compare and evaluate different machine learning architectures for natural language processing",
+        ]
+        
+        for prompt in complex_prompts:
+            complexity = handler.analyze_complexity(prompt)
+            print(f"  '{prompt[:40]}...' -> {complexity}")
+            assert complexity == 'complex', f"Expected 'complex' for: {prompt}"
+        
+        print("✅ Complex prompts correctly classified")
+    
+    def test_model_selection_by_complexity(self):
+        """Test model selection based on complexity."""
+        handler = RouterHandler(verbose=True)
+        
+        # Simple task - should select cheap model
+        simple_model = handler.select_model("What is the capital of France?")
+        print(f"Simple task model: {simple_model}")
+        assert simple_model in ['gpt-4o-mini', 'claude-3-haiku', 'gemini-1.5-flash']
+        
+        # Complex task - should select powerful model
+        complex_model = handler.select_model(
+            "Analyze and research the comprehensive impact of quantum computing on cybersecurity"
+        )
+        print(f"Complex task model: {complex_model}")
+        assert complex_model in ['gpt-4-turbo', 'claude-3-opus', 'o1-preview']
+        
+        print("✅ Model selection by complexity works correctly")
+    
+    def test_model_selection_with_provider_preference(self):
+        """Test model selection with provider preference."""
+        handler = RouterHandler(verbose=True)
+        
+        # Prefer OpenAI
+        openai_model = handler.select_model(
+            "Write a simple greeting",
+            preferred_provider='openai'
+        )
+        print(f"OpenAI preferred: {openai_model}")
+        assert 'gpt' in openai_model.lower() or 'o1' in openai_model.lower()
+        
+        # Prefer Anthropic
+        anthropic_model = handler.select_model(
+            "Write a simple greeting",
+            preferred_provider='anthropic'
+        )
+        print(f"Anthropic preferred: {anthropic_model}")
+        assert 'claude' in anthropic_model.lower()
+        
+        # Prefer Google
+        google_model = handler.select_model(
+            "Write a simple greeting",
+            preferred_provider='google'
+        )
+        print(f"Google preferred: {google_model}")
+        assert 'gemini' in google_model.lower()
+        
+        print("✅ Provider preference works correctly")
+    
+    def test_custom_models_from_yaml(self):
+        """Test loading custom models from YAML-like config."""
+        handler = RouterHandler(verbose=True)
+        
+        # Define custom models (as would be in YAML)
+        custom_models = {
+            'my-cheap-model': {
+                'provider': 'openai',
+                'complexity': ['simple'],
+                'cost_per_1k': 0.0001,
+                'capabilities': ['text']
+            },
+            'my-balanced-model': {
+                'provider': 'openai',
+                'complexity': ['moderate'],
+                'cost_per_1k': 0.001,
+                'capabilities': ['text', 'function-calling']
+            },
+            'my-premium-model': {
+                'provider': 'anthropic',
+                'complexity': ['complex', 'very_complex'],
+                'cost_per_1k': 0.015,
+                'capabilities': ['text', 'vision', 'function-calling']
+            }
+        }
+        
+        # Load custom models
+        handler.load_models_from_config(custom_models)
+        
+        # Verify models are loaded
+        available = handler.get_available_models()
+        print(f"Available models: {available}")
+        
+        assert 'my-cheap-model' in available
+        assert 'my-balanced-model' in available
+        assert 'my-premium-model' in available
+        
+        # Test selection with custom models
+        simple_model = handler.select_model("What is 2+2?")
+        print(f"Simple task -> {simple_model}")
+        assert simple_model == 'my-cheap-model'
+        
+        complex_model = handler.select_model(
+            "Analyze and research the comprehensive impact of AI"
+        )
+        print(f"Complex task -> {complex_model}")
+        assert complex_model == 'my-premium-model'
+        
+        print("✅ Custom models from YAML config work correctly")
+    
+    def test_cost_threshold(self):
+        """Test cost threshold filtering."""
+        handler = RouterHandler(verbose=True)
+        
+        # Load models with different costs
+        custom_models = {
+            'cheap': {
+                'provider': 'openai',
+                'complexity': ['simple', 'moderate', 'complex'],
+                'cost_per_1k': 0.0001,
+                'capabilities': ['text']
+            },
+            'expensive': {
+                'provider': 'anthropic',
+                'complexity': ['simple', 'moderate', 'complex'],
+                'cost_per_1k': 0.05,
+                'capabilities': ['text']
+            }
+        }
+        
+        handler.load_models_from_config(custom_models)
+        
+        # Set cost threshold
+        handler.set_cost_threshold(0.001)
+        
+        # Should only select cheap model
+        model = handler.select_model("Any task here")
+        print(f"With cost threshold 0.001: {model}")
+        assert model == 'cheap'
+        
+        # Verify cost
+        cost = handler.get_model_cost(model)
+        assert cost <= 0.001
+        
+        print("✅ Cost threshold filtering works correctly")
+    
+    def test_merge_with_defaults(self):
+        """Test merging custom models with defaults."""
+        handler = RouterHandler(verbose=True)
+        
+        custom_models = {
+            'my-custom-model': {
+                'provider': 'custom',
+                'complexity': ['moderate'],
+                'cost_per_1k': 0.002,
+                'capabilities': ['text']
+            }
+        }
+        
+        handler.load_models_from_config(custom_models, merge_with_defaults=True)
+        
+        available = handler.get_available_models()
+        print(f"Available models (merged): {available}")
+        
+        # Should have both custom and default models
+        assert 'my-custom-model' in available
+        assert 'gpt-4o-mini' in available
+        
+        print("✅ Merge with defaults works correctly")
+
+
+class TestRealAPIIntegration:
+    """Tests that make real API calls - requires API keys."""
+    
+    @pytest.mark.skipif(
+        not os.getenv('OPENAI_API_KEY') or 
+        'test' in os.getenv('OPENAI_API_KEY', '').lower() or
+        not os.getenv('OPENAI_API_KEY', '').startswith('sk-') or
+        len(os.getenv('OPENAI_API_KEY', '')) < 40,
+        reason="OPENAI_API_KEY not set or using test/invalid key"
+    )
+    def test_real_openai_call(self):
+        """Test real OpenAI API call with routed model."""
+        from praisonaiagents import Agent
+        
+        handler = RouterHandler(verbose=True)
+        
+        # Select model for simple task
+        model = handler.select_model(
+            "What is 2+2?",
+            preferred_provider='openai'
+        )
+        print(f"Selected model: {model}")
+        
+        # Create agent with selected model
+        agent = Agent(
+            name="TestAgent",
+            role="Calculator",
+            goal="Answer simple math questions",
+            llm=model,
+            verbose=True
+        )
+        
+        # Run simple task
+        result = agent.start("What is 2+2? Answer with just the number.")
+        print(f"Result: {result}")
+        
+        assert '4' in str(result)
+        print("✅ Real OpenAI API call successful")
+    
+    @pytest.mark.skipif(
+        not os.getenv('ANTHROPIC_API_KEY'),
+        reason="ANTHROPIC_API_KEY not set"
+    )
+    def test_real_anthropic_call(self):
+        """Test real Anthropic API call with routed model."""
+        from praisonaiagents import Agent
+        
+        handler = RouterHandler(verbose=True)
+        
+        # Select Anthropic model
+        model = handler.select_model(
+            "What is the capital of France?",
+            preferred_provider='anthropic'
+        )
+        print(f"Selected model: {model}")
+        
+        # Create agent with selected model
+        agent = Agent(
+            name="TestAgent",
+            role="Geography Expert",
+            goal="Answer geography questions",
+            llm=model,
+            verbose=True
+        )
+        
+        # Run task
+        result = agent.start("What is the capital of France? Answer with just the city name.")
+        print(f"Result: {result}")
+        
+        assert 'paris' in str(result).lower()
+        print("✅ Real Anthropic API call successful")
+    
+    @pytest.mark.skipif(
+        not os.getenv('GEMINI_API_KEY'),
+        reason="GEMINI_API_KEY not set"
+    )
+    def test_real_gemini_call(self):
+        """Test real Gemini API call with routed model."""
+        from praisonaiagents import Agent
+        
+        handler = RouterHandler(verbose=True)
+        
+        # Select Google model
+        model = handler.select_model(
+            "What is 3 times 7?",
+            preferred_provider='google'
+        )
+        print(f"Selected model: {model}")
+        
+        # Create agent with selected model
+        agent = Agent(
+            name="TestAgent",
+            role="Calculator",
+            goal="Answer math questions",
+            llm=f"gemini/{model}" if not model.startswith("gemini/") else model,
+            verbose=True
+        )
+        
+        # Run task
+        result = agent.start("What is 3 times 7? Answer with just the number.")
+        print(f"Result: {result}")
+        
+        assert '21' in str(result)
+        print("✅ Real Gemini API call successful")
+
+
+if __name__ == '__main__':
+    # Run tests
+    pytest.main([__file__, '-v', '-s'])

src/praisonai/tests/test_approval_system.py

@@ -0,0 +1,221 @@
+"""
+Tests for the CLI approval system.
+
+Tests:
+1. --trust flag auto-approves all tools
+2. --approve-level flag with different risk levels
+3. Approval callback integration
+"""
+
+import pytest
+import sys
+import os
+
+# Add the src directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+
+class TestApprovalFlags:
+    """Test CLI approval flags."""
+    
+    def test_trust_flag_exists(self):
+        """Test that --trust flag is defined in argparse."""
+        import argparse
+        
+        # Check that the args object has the trust attribute after parsing
+        # Parse with --help to avoid actually running anything
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--trust", action="store_true")
+        parser.add_argument("--approve-level", type=str, choices=["low", "medium", "high", "critical"])
+        
+        # Test that the arguments can be parsed
+        args = parser.parse_args(['--trust'])
+        assert args.trust is True
+        
+        args = parser.parse_args([])
+        assert args.trust is False
+    
+    def test_approve_level_flag_exists(self):
+        """Test that --approve-level flag is defined in argparse."""
+        import argparse
+        
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--approve-level", type=str, choices=["low", "medium", "high", "critical"])
+        
+        # Test that the arguments can be parsed
+        args = parser.parse_args(['--approve-level', 'high'])
+        assert args.approve_level == 'high'
+        
+        args = parser.parse_args(['--approve-level', 'critical'])
+        assert args.approve_level == 'critical'
+    
+    def test_trust_flag_in_praisonai_parser(self):
+        """Test that --trust flag is in PraisonAI's actual parser."""
+        from praisonai.cli.main import PraisonAI
+        
+        # Create instance - parse_args is called in __init__
+        praison = PraisonAI()
+        
+        # Call parse_args to get the args
+        args = praison.parse_args()
+        
+        # The args should have trust attribute after parse_args
+        assert hasattr(args, 'trust'), "PraisonAI.args should have 'trust' attribute"
+        # Cleanup
+        del praison
+    
+    def test_approve_level_flag_in_praisonai_parser(self):
+        """Test that --approve-level flag is in PraisonAI's actual parser."""
+        from praisonai.cli.main import PraisonAI
+        
+        # Create instance - parse_args is called in __init__
+        praison = PraisonAI()
+        
+        # Call parse_args to get the args
+        args = praison.parse_args()
+        
+        # The args should have approve_level attribute after parse_args
+        assert hasattr(args, 'approve_level'), "PraisonAI.args should have 'approve_level' attribute"
+
+
+class TestApprovalCallback:
+    """Test approval callback system."""
+    
+    def test_set_approval_callback(self):
+        """Test that we can set a custom approval callback."""
+        from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+        
+        callback_called = []
+        
+        def custom_callback(function_name, arguments, risk_level):
+            callback_called.append((function_name, arguments, risk_level))
+            return ApprovalDecision(approved=True, reason="Test approved")
+        
+        set_approval_callback(custom_callback)
+        
+        # Verify callback was set
+        from praisonaiagents.approval import approval_callback
+        assert approval_callback == custom_callback
+        
+        # Reset callback
+        set_approval_callback(None)
+    
+    def test_auto_approve_callback(self):
+        """Test auto-approve callback returns approved decision."""
+        from praisonaiagents.approval import ApprovalDecision
+        
+        def auto_approve_callback(function_name, arguments, risk_level):
+            return ApprovalDecision(approved=True, reason="Auto-approved")
+        
+        decision = auto_approve_callback("execute_command", {"command": "ls"}, "critical")
+        assert decision.approved is True
+        assert decision.reason == "Auto-approved"
+    
+    def test_level_based_callback(self):
+        """Test level-based approval callback."""
+        from praisonaiagents.approval import ApprovalDecision
+        
+        def level_based_callback(function_name, arguments, risk_level, max_level="high"):
+            """Approve based on risk level threshold."""
+            levels = {"low": 1, "medium": 2, "high": 3, "critical": 4}
+            tool_level = levels.get(risk_level, 4)
+            max_allowed = levels.get(max_level, 3)
+            
+            if tool_level <= max_allowed:
+                return ApprovalDecision(approved=True, reason=f"Auto-approved (level {risk_level} <= {max_level})")
+            else:
+                return ApprovalDecision(approved=False, reason=f"Denied (level {risk_level} > {max_level})")
+        
+        # Test with max_level="high"
+        # Should approve low, medium, high but deny critical
+        assert level_based_callback("test", {}, "low", "high").approved is True
+        assert level_based_callback("test", {}, "medium", "high").approved is True
+        assert level_based_callback("test", {}, "high", "high").approved is True
+        assert level_based_callback("test", {}, "critical", "high").approved is False
+        
+        # Test with max_level="critical"
+        # Should approve everything
+        assert level_based_callback("test", {}, "critical", "critical").approved is True
+
+
+class TestApprovalRequirements:
+    """Test approval requirement configuration."""
+    
+    def test_default_dangerous_tools(self):
+        """Test that default dangerous tools are configured."""
+        from praisonaiagents.approval import APPROVAL_REQUIRED_TOOLS, TOOL_RISK_LEVELS
+        
+        # Check critical tools
+        assert "execute_command" in APPROVAL_REQUIRED_TOOLS
+        assert TOOL_RISK_LEVELS.get("execute_command") == "critical"
+        
+        # Check high risk tools
+        assert "write_file" in APPROVAL_REQUIRED_TOOLS
+        assert TOOL_RISK_LEVELS.get("write_file") == "high"
+    
+    def test_remove_approval_requirement(self):
+        """Test removing approval requirement."""
+        from praisonaiagents.approval import (
+            add_approval_requirement, 
+            remove_approval_requirement,
+            is_approval_required,
+            APPROVAL_REQUIRED_TOOLS
+        )
+        
+        # Add a test tool
+        add_approval_requirement("test_tool", "medium")
+        assert is_approval_required("test_tool") is True
+        
+        # Remove it
+        remove_approval_requirement("test_tool")
+        assert is_approval_required("test_tool") is False
+    
+    def test_is_approval_required(self):
+        """Test checking if approval is required."""
+        from praisonaiagents.approval import is_approval_required
+        
+        # execute_command should require approval
+        assert is_approval_required("execute_command") is True
+        
+        # read_file should not require approval
+        assert is_approval_required("read_file") is False
+        
+        # list_files should not require approval
+        assert is_approval_required("list_files") is False
+
+
+class TestApprovalDecision:
+    """Test ApprovalDecision class."""
+    
+    def test_approval_decision_approved(self):
+        """Test approved decision."""
+        from praisonaiagents.approval import ApprovalDecision
+        
+        decision = ApprovalDecision(approved=True, reason="User approved")
+        assert decision.approved is True
+        assert decision.reason == "User approved"
+        assert decision.modified_args == {}
+    
+    def test_approval_decision_denied(self):
+        """Test denied decision."""
+        from praisonaiagents.approval import ApprovalDecision
+        
+        decision = ApprovalDecision(approved=False, reason="User denied")
+        assert decision.approved is False
+        assert decision.reason == "User denied"
+    
+    def test_approval_decision_with_modified_args(self):
+        """Test decision with modified arguments."""
+        from praisonaiagents.approval import ApprovalDecision
+        
+        decision = ApprovalDecision(
+            approved=True, 
+            reason="Approved with modifications",
+            modified_args={"command": "ls -la"}
+        )
+        assert decision.approved is True
+        assert decision.modified_args == {"command": "ls -la"}
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

src/praisonai/tests/unit/cli/test_at_mentions.py

@@ -0,0 +1,289 @@
+"""
+Unit tests for @ mention autocomplete feature.
+
+Tests for:
+1. AtMentionContext - Context detection
+2. FileSearchService - File search with fuzzy matching
+3. AtMentionCompleter - Autocomplete integration
+"""
+
+import os
+import tempfile
+import time
+
+
+# ============================================================================
+# 1. AtMentionContext Tests
+# ============================================================================
+
+class TestAtMentionContext:
+    """Test @ mention context detection."""
+    
+    def test_detect_at_start(self):
+        """Should detect @ at start of input."""
+        from praisonai.cli.features.at_mentions import detect_at_mention
+        
+        result = detect_at_mention("@", cursor_pos=1)
+        assert result is not None
+        assert result.is_active
+        assert result.query == ""
+        assert result.start_pos == 0
+    
+    def test_detect_at_with_query(self):
+        """Should detect @ with partial query."""
+        from praisonai.cli.features.at_mentions import detect_at_mention
+        
+        result = detect_at_mention("@main", cursor_pos=5)
+        assert result is not None
+        assert result.is_active
+        assert result.query == "main"
+        assert result.start_pos == 0
+    
+    def test_detect_at_mid_text(self):
+        """Should detect @ in middle of text."""
+        from praisonai.cli.features.at_mentions import detect_at_mention
+        
+        result = detect_at_mention("read @src/", cursor_pos=10)
+        assert result is not None
+        assert result.is_active
+        assert result.query == "src/"
+        assert result.start_pos == 5
+    
+    def test_no_at_symbol(self):
+        """Should return None when no @ present."""
+        from praisonai.cli.features.at_mentions import detect_at_mention
+        
+        result = detect_at_mention("hello world", cursor_pos=11)
+        assert result is None
+    
+    def test_at_after_space_breaks_context(self):
+        """Should not detect @ if space after query."""
+        from praisonai.cli.features.at_mentions import detect_at_mention
+        
+        result = detect_at_mention("@file.txt ", cursor_pos=10)
+        assert result is None  # Space breaks the @ context
+    
+    def test_cursor_before_at(self):
+        """Should not detect if cursor is before @."""
+        from praisonai.cli.features.at_mentions import detect_at_mention
+        
+        result = detect_at_mention("hello @file", cursor_pos=3)
+        assert result is None
+
+
+# ============================================================================
+# 2. FileSuggestion Tests
+# ============================================================================
+
+class TestFileSuggestion:
+    """Test FileSuggestion dataclass."""
+    
+    def test_create_file_suggestion(self):
+        """Should create file suggestion."""
+        from praisonai.cli.features.at_mentions import FileSuggestion
+        
+        suggestion = FileSuggestion(
+            path="src/main.py",
+            file_type="file",
+            score=100
+        )
+        assert suggestion.path == "src/main.py"
+        assert suggestion.file_type == "file"
+        assert suggestion.score == 100
+    
+    def test_directory_suggestion(self):
+        """Should create directory suggestion."""
+        from praisonai.cli.features.at_mentions import FileSuggestion
+        
+        suggestion = FileSuggestion(
+            path="src/",
+            file_type="directory",
+            score=90
+        )
+        assert suggestion.file_type == "directory"
+
+
+# ============================================================================
+# 3. FileSearchService Tests
+# ============================================================================
+
+class TestFileSearchService:
+    """Test FileSearchService for file discovery."""
+    
+    def test_service_creation(self):
+        """Should create service."""
+        from praisonai.cli.features.at_mentions import FileSearchService
+        
+        service = FileSearchService(root_dir=".")
+        assert service is not None
+    
+    def test_search_files(self):
+        """Should search files in directory."""
+        from praisonai.cli.features.at_mentions import FileSearchService
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create test files
+            open(os.path.join(tmpdir, "main.py"), "w").close()
+            open(os.path.join(tmpdir, "test.py"), "w").close()
+            os.makedirs(os.path.join(tmpdir, "src"))
+            open(os.path.join(tmpdir, "src", "app.py"), "w").close()
+            
+            service = FileSearchService(root_dir=tmpdir)
+            results = service.search("main")
+            
+            assert len(results) >= 1
+            assert any("main.py" in r.path for r in results)
+    
+    def test_fuzzy_match(self):
+        """Should fuzzy match file names."""
+        from praisonai.cli.features.at_mentions import FileSearchService
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            open(os.path.join(tmpdir, "my_long_filename.py"), "w").close()
+            
+            service = FileSearchService(root_dir=tmpdir)
+            results = service.search("mlf")  # Fuzzy match
+            
+            assert len(results) >= 1
+    
+    def test_empty_query_returns_all(self):
+        """Should return files when query is empty."""
+        from praisonai.cli.features.at_mentions import FileSearchService
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            open(os.path.join(tmpdir, "a.py"), "w").close()
+            open(os.path.join(tmpdir, "b.py"), "w").close()
+            
+            service = FileSearchService(root_dir=tmpdir)
+            results = service.search("")
+            
+            assert len(results) >= 2
+    
+    def test_respects_max_results(self):
+        """Should limit results."""
+        from praisonai.cli.features.at_mentions import FileSearchService
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            for i in range(20):
+                open(os.path.join(tmpdir, f"file{i}.py"), "w").close()
+            
+            service = FileSearchService(root_dir=tmpdir)
+            results = service.search("", max_results=5)
+            
+            assert len(results) <= 5
+    
+    def test_cache_works(self):
+        """Should cache results."""
+        from praisonai.cli.features.at_mentions import FileSearchService
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            open(os.path.join(tmpdir, "test.py"), "w").close()
+            
+            service = FileSearchService(root_dir=tmpdir, cache_ttl=10)
+            
+            # First search
+            start = time.time()
+            results1 = service.search("test")
+            first_time = time.time() - start
+            
+            # Second search (cached)
+            start = time.time()
+            results2 = service.search("test")
+            second_time = time.time() - start
+            
+            assert len(results1) == len(results2)
+            # Cache should be faster (or at least not slower)
+
+
+# ============================================================================
+# 4. AtMentionCompleter Tests
+# ============================================================================
+
+class TestAtMentionCompleter:
+    """Test AtMentionCompleter for prompt_toolkit integration."""
+    
+    def test_completer_creation(self):
+        """Should create completer."""
+        from praisonai.cli.features.at_mentions import AtMentionCompleter
+        
+        completer = AtMentionCompleter(root_dir=".")
+        assert completer is not None
+    
+    def test_no_completions_without_at(self):
+        """Should not complete without @."""
+        from praisonai.cli.features.at_mentions import AtMentionCompleter
+        from prompt_toolkit.document import Document
+        
+        completer = AtMentionCompleter(root_dir=".")
+        doc = Document("hello world")
+        completions = list(completer.get_completions(doc, None))
+        
+        assert len(completions) == 0
+    
+    def test_completions_with_at(self):
+        """Should complete with @."""
+        from praisonai.cli.features.at_mentions import AtMentionCompleter
+        from prompt_toolkit.document import Document
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            open(os.path.join(tmpdir, "main.py"), "w").close()
+            
+            completer = AtMentionCompleter(root_dir=tmpdir)
+            doc = Document("@main")
+            completions = list(completer.get_completions(doc, None))
+            
+            assert len(completions) >= 1
+
+
+# ============================================================================
+# 5. CombinedCompleter Tests
+# ============================================================================
+
+class TestCombinedCompleter:
+    """Test CombinedCompleter that handles both / and @."""
+    
+    def test_slash_commands(self):
+        """Should complete slash commands."""
+        from praisonai.cli.features.at_mentions import CombinedCompleter
+        from prompt_toolkit.document import Document
+        
+        completer = CombinedCompleter(
+            commands=["help", "exit", "queue"],
+            root_dir="."
+        )
+        doc = Document("/he")
+        completions = list(completer.get_completions(doc, None))
+        
+        assert len(completions) >= 1
+        assert any("/help" in c.text for c in completions)
+    
+    def test_at_mentions(self):
+        """Should complete @ mentions."""
+        from praisonai.cli.features.at_mentions import CombinedCompleter
+        from prompt_toolkit.document import Document
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            open(os.path.join(tmpdir, "test.py"), "w").close()
+            
+            completer = CombinedCompleter(
+                commands=["help"],
+                root_dir=tmpdir
+            )
+            doc = Document("@test")
+            completions = list(completer.get_completions(doc, None))
+            
+            assert len(completions) >= 1
+    
+    def test_no_completions_for_regular_text(self):
+        """Should not complete regular text."""
+        from praisonai.cli.features.at_mentions import CombinedCompleter
+        from prompt_toolkit.document import Document
+        
+        completer = CombinedCompleter(
+            commands=["help"],
+            root_dir="."
+        )
+        doc = Document("hello world")
+        completions = list(completer.get_completions(doc, None))
+        
+        assert len(completions) == 0

src/praisonai/tests/unit/cli/test_autonomy_mode.py

@@ -0,0 +1,590 @@
+"""
+Tests for Autonomy Mode System.
+
+Test-Driven Development approach for autonomy/approval modes.
+"""
+
+import pytest
+from unittest.mock import MagicMock
+
+from praisonai.cli.features.autonomy_mode import (
+    AutonomyMode,
+    ActionType,
+    ActionRequest,
+    ApprovalResult,
+    AutonomyPolicy,
+    AutonomyManager,
+    AutonomyModeHandler,
+    create_file_write_action,
+    create_shell_command_action,
+    create_git_action,
+    create_tool_call_action,
+)
+
+
+# ============================================================================
+# AutonomyMode Tests
+# ============================================================================
+
+class TestAutonomyMode:
+    """Tests for AutonomyMode enum."""
+    
+    def test_mode_values(self):
+        """Test mode enum values."""
+        assert AutonomyMode.SUGGEST.value == "suggest"
+        assert AutonomyMode.AUTO_EDIT.value == "auto_edit"
+        assert AutonomyMode.FULL_AUTO.value == "full_auto"
+    
+    def test_from_string_valid(self):
+        """Test parsing valid mode strings."""
+        assert AutonomyMode.from_string("suggest") == AutonomyMode.SUGGEST
+        assert AutonomyMode.from_string("auto_edit") == AutonomyMode.AUTO_EDIT
+        assert AutonomyMode.from_string("full_auto") == AutonomyMode.FULL_AUTO
+    
+    def test_from_string_with_hyphen(self):
+        """Test parsing mode strings with hyphens."""
+        assert AutonomyMode.from_string("auto-edit") == AutonomyMode.AUTO_EDIT
+        assert AutonomyMode.from_string("full-auto") == AutonomyMode.FULL_AUTO
+    
+    def test_from_string_case_insensitive(self):
+        """Test case insensitive parsing."""
+        assert AutonomyMode.from_string("SUGGEST") == AutonomyMode.SUGGEST
+        assert AutonomyMode.from_string("Auto_Edit") == AutonomyMode.AUTO_EDIT
+    
+    def test_from_string_invalid(self):
+        """Test parsing invalid mode string."""
+        with pytest.raises(ValueError, match="Unknown autonomy mode"):
+            AutonomyMode.from_string("invalid_mode")
+
+
+# ============================================================================
+# ActionType Tests
+# ============================================================================
+
+class TestActionType:
+    """Tests for ActionType enum."""
+    
+    def test_action_types_exist(self):
+        """Test all action types exist."""
+        assert ActionType.FILE_READ.value == "file_read"
+        assert ActionType.FILE_WRITE.value == "file_write"
+        assert ActionType.FILE_DELETE.value == "file_delete"
+        assert ActionType.SHELL_COMMAND.value == "shell_command"
+        assert ActionType.NETWORK_REQUEST.value == "network_request"
+        assert ActionType.CODE_EXECUTION.value == "code_execution"
+        assert ActionType.GIT_OPERATION.value == "git_operation"
+        assert ActionType.TOOL_CALL.value == "tool_call"
+
+
+# ============================================================================
+# ActionRequest Tests
+# ============================================================================
+
+class TestActionRequest:
+    """Tests for ActionRequest dataclass."""
+    
+    def test_create_basic_action(self):
+        """Test creating a basic action request."""
+        action = ActionRequest(
+            action_type=ActionType.FILE_WRITE,
+            description="Write to config.py"
+        )
+        assert action.action_type == ActionType.FILE_WRITE
+        assert action.description == "Write to config.py"
+        assert action.details == {}
+        assert action.risk_level == "medium"
+        assert action.reversible is True
+    
+    def test_create_action_with_details(self):
+        """Test creating action with details."""
+        action = ActionRequest(
+            action_type=ActionType.SHELL_COMMAND,
+            description="Run tests",
+            details={"command": "pytest", "cwd": "/project"},
+            risk_level="low",
+            reversible=False
+        )
+        assert action.details["command"] == "pytest"
+        assert action.risk_level == "low"
+        assert action.reversible is False
+    
+    def test_action_str(self):
+        """Test action string representation."""
+        action = ActionRequest(
+            action_type=ActionType.FILE_WRITE,
+            description="Write to file.py"
+        )
+        assert "file_write" in str(action)
+        assert "Write to file.py" in str(action)
+
+
+# ============================================================================
+# ApprovalResult Tests
+# ============================================================================
+
+class TestApprovalResult:
+    """Tests for ApprovalResult dataclass."""
+    
+    def test_approved_result(self):
+        """Test approved result."""
+        result = ApprovalResult(approved=True)
+        assert result.approved is True
+        assert result.reason is None
+        assert result.remember_choice is False
+    
+    def test_denied_result_with_reason(self):
+        """Test denied result with reason."""
+        result = ApprovalResult(
+            approved=False,
+            reason="User denied the action"
+        )
+        assert result.approved is False
+        assert result.reason == "User denied the action"
+    
+    def test_result_with_remember(self):
+        """Test result with remember choice."""
+        result = ApprovalResult(
+            approved=True,
+            remember_choice=True
+        )
+        assert result.remember_choice is True
+
+
+# ============================================================================
+# AutonomyPolicy Tests
+# ============================================================================
+
+class TestAutonomyPolicy:
+    """Tests for AutonomyPolicy."""
+    
+    def test_suggest_mode_policy(self):
+        """Test policy for suggest mode."""
+        policy = AutonomyPolicy.for_mode(AutonomyMode.SUGGEST)
+        
+        assert policy.mode == AutonomyMode.SUGGEST
+        assert ActionType.FILE_READ in policy.auto_approve
+        assert ActionType.FILE_WRITE in policy.require_approval
+        assert ActionType.SHELL_COMMAND in policy.require_approval
+        assert policy.show_preview is True
+    
+    def test_auto_edit_mode_policy(self):
+        """Test policy for auto-edit mode."""
+        policy = AutonomyPolicy.for_mode(AutonomyMode.AUTO_EDIT)
+        
+        assert policy.mode == AutonomyMode.AUTO_EDIT
+        assert ActionType.FILE_READ in policy.auto_approve
+        assert ActionType.FILE_WRITE in policy.auto_approve
+        assert ActionType.SHELL_COMMAND in policy.require_approval
+        assert ActionType.FILE_DELETE in policy.require_approval
+    
+    def test_full_auto_mode_policy(self):
+        """Test policy for full-auto mode."""
+        policy = AutonomyPolicy.for_mode(AutonomyMode.FULL_AUTO)
+        
+        assert policy.mode == AutonomyMode.FULL_AUTO
+        assert ActionType.FILE_WRITE in policy.auto_approve
+        assert ActionType.SHELL_COMMAND in policy.auto_approve
+        assert ActionType.FILE_DELETE in policy.auto_approve
+        assert len(policy.require_approval) == 0
+        assert policy.max_auto_actions == 100
+    
+    def test_custom_policy(self):
+        """Test creating custom policy."""
+        policy = AutonomyPolicy(
+            mode=AutonomyMode.SUGGEST,
+            auto_approve={ActionType.FILE_READ, ActionType.TOOL_CALL},
+            blocked={ActionType.FILE_DELETE},
+            trusted_paths={"/safe/path"}
+        )
+        
+        assert ActionType.TOOL_CALL in policy.auto_approve
+        assert ActionType.FILE_DELETE in policy.blocked
+        assert "/safe/path" in policy.trusted_paths
+
+
+# ============================================================================
+# AutonomyManager Tests
+# ============================================================================
+
+class TestAutonomyManager:
+    """Tests for AutonomyManager."""
+    
+    def test_create_manager_default(self):
+        """Test creating manager with defaults."""
+        manager = AutonomyManager()
+        
+        assert manager.mode == AutonomyMode.SUGGEST
+        assert manager.policy is not None
+    
+    def test_create_manager_with_mode(self):
+        """Test creating manager with specific mode."""
+        manager = AutonomyManager(mode=AutonomyMode.FULL_AUTO)
+        
+        assert manager.mode == AutonomyMode.FULL_AUTO
+    
+    def test_set_mode(self):
+        """Test changing mode."""
+        manager = AutonomyManager(mode=AutonomyMode.SUGGEST)
+        manager.set_mode(AutonomyMode.AUTO_EDIT)
+        
+        assert manager.mode == AutonomyMode.AUTO_EDIT
+    
+    def test_auto_approve_file_read(self):
+        """Test auto-approval of file read in suggest mode."""
+        manager = AutonomyManager(mode=AutonomyMode.SUGGEST)
+        
+        action = ActionRequest(
+            action_type=ActionType.FILE_READ,
+            description="Read config.py"
+        )
+        
+        result = manager.request_approval(action)
+        
+        assert result.approved is True
+        assert "Auto-approved" in result.reason
+    
+    def test_require_approval_file_write_suggest(self):
+        """Test file write requires approval in suggest mode."""
+        # Mock the approval callback
+        mock_callback = MagicMock(return_value=ApprovalResult(approved=True))
+        manager = AutonomyManager(
+            mode=AutonomyMode.SUGGEST,
+            approval_callback=mock_callback
+        )
+        
+        action = ActionRequest(
+            action_type=ActionType.FILE_WRITE,
+            description="Write to config.py"
+        )
+        
+        result = manager.request_approval(action)
+        
+        assert result.approved is True
+        mock_callback.assert_called_once()
+    
+    def test_auto_approve_file_write_auto_edit(self):
+        """Test file write is auto-approved in auto-edit mode."""
+        manager = AutonomyManager(mode=AutonomyMode.AUTO_EDIT)
+        
+        action = ActionRequest(
+            action_type=ActionType.FILE_WRITE,
+            description="Write to config.py"
+        )
+        
+        result = manager.request_approval(action)
+        
+        assert result.approved is True
+        assert "Auto-approved" in result.reason
+    
+    def test_auto_approve_everything_full_auto(self):
+        """Test everything is auto-approved in full-auto mode."""
+        manager = AutonomyManager(mode=AutonomyMode.FULL_AUTO)
+        
+        actions = [
+            ActionRequest(ActionType.FILE_WRITE, "Write file"),
+            ActionRequest(ActionType.SHELL_COMMAND, "Run command"),
+            ActionRequest(ActionType.FILE_DELETE, "Delete file"),
+        ]
+        
+        for action in actions:
+            result = manager.request_approval(action)
+            assert result.approved is True
+    
+    def test_blocked_action(self):
+        """Test blocked action is denied."""
+        policy = AutonomyPolicy(
+            mode=AutonomyMode.SUGGEST,
+            blocked={ActionType.FILE_DELETE}
+        )
+        manager = AutonomyManager(mode=AutonomyMode.SUGGEST, policy=policy)
+        
+        action = ActionRequest(
+            action_type=ActionType.FILE_DELETE,
+            description="Delete important file"
+        )
+        
+        result = manager.request_approval(action)
+        
+        assert result.approved is False
+        assert "blocked" in result.reason.lower()
+    
+    def test_remember_approval(self):
+        """Test remembered approval decisions."""
+        mock_callback = MagicMock(return_value=ApprovalResult(
+            approved=True,
+            remember_choice=True
+        ))
+        manager = AutonomyManager(
+            mode=AutonomyMode.SUGGEST,
+            approval_callback=mock_callback
+        )
+        
+        action = ActionRequest(
+            action_type=ActionType.FILE_WRITE,
+            description="Write to config.py",
+            details={"path": "/project/config.py"}
+        )
+        
+        # First request - should call callback
+        result1 = manager.request_approval(action)
+        assert result1.approved is True
+        assert mock_callback.call_count == 1
+        
+        # Second request - should use remembered choice
+        result2 = manager.request_approval(action)
+        assert result2.approved is True
+        assert mock_callback.call_count == 1  # Not called again
+    
+    def test_max_auto_actions(self):
+        """Test max auto actions limit."""
+        mock_callback = MagicMock(return_value=ApprovalResult(approved=True))
+        policy = AutonomyPolicy(
+            mode=AutonomyMode.SUGGEST,
+            auto_approve={ActionType.FILE_READ},
+            max_auto_actions=3
+        )
+        manager = AutonomyManager(
+            mode=AutonomyMode.SUGGEST,
+            policy=policy,
+            approval_callback=mock_callback
+        )
+        
+        action = ActionRequest(ActionType.FILE_READ, "Read file")
+        
+        # First 3 should be auto-approved
+        for _ in range(3):
+            result = manager.request_approval(action)
+            assert result.approved is True
+        
+        # 4th should require approval (callback called)
+        result = manager.request_approval(action)
+        assert mock_callback.call_count == 1
+    
+    def test_get_stats(self):
+        """Test getting approval statistics."""
+        manager = AutonomyManager(mode=AutonomyMode.FULL_AUTO)
+        
+        # Perform some actions
+        manager.request_approval(ActionRequest(ActionType.FILE_READ, "Read"))
+        manager.request_approval(ActionRequest(ActionType.FILE_WRITE, "Write"))
+        
+        stats = manager.get_stats()
+        
+        assert stats["total_actions"] == 2
+        assert stats["auto_approved"] == 2
+        assert stats["denied"] == 0
+    
+    def test_reset_stats(self):
+        """Test resetting statistics."""
+        manager = AutonomyManager(mode=AutonomyMode.FULL_AUTO)
+        
+        manager.request_approval(ActionRequest(ActionType.FILE_READ, "Read"))
+        manager.reset_stats()
+        
+        stats = manager.get_stats()
+        assert stats["total_actions"] == 0
+    
+    def test_clear_remembered(self):
+        """Test clearing remembered approvals."""
+        mock_callback = MagicMock(return_value=ApprovalResult(
+            approved=True,
+            remember_choice=True
+        ))
+        manager = AutonomyManager(
+            mode=AutonomyMode.SUGGEST,
+            approval_callback=mock_callback
+        )
+        
+        action = ActionRequest(ActionType.FILE_WRITE, "Write", details={"path": "/a"})
+        
+        # Remember approval
+        manager.request_approval(action)
+        assert mock_callback.call_count == 1
+        
+        # Clear remembered
+        manager.clear_remembered()
+        
+        # Should call callback again
+        manager.request_approval(action)
+        assert mock_callback.call_count == 2
+
+
+# ============================================================================
+# AutonomyModeHandler Tests
+# ============================================================================
+
+class TestAutonomyModeHandler:
+    """Tests for AutonomyModeHandler."""
+    
+    def test_handler_creation(self):
+        """Test handler creation."""
+        handler = AutonomyModeHandler()
+        assert handler.feature_name == "autonomy_mode"
+    
+    def test_initialize_default(self):
+        """Test initializing with defaults."""
+        handler = AutonomyModeHandler()
+        manager = handler.initialize()
+        
+        assert manager is not None
+        assert manager.mode == AutonomyMode.SUGGEST
+    
+    def test_initialize_with_mode(self):
+        """Test initializing with specific mode."""
+        handler = AutonomyModeHandler()
+        manager = handler.initialize(mode="full_auto")
+        
+        assert manager.mode == AutonomyMode.FULL_AUTO
+    
+    def test_initialize_invalid_mode(self):
+        """Test initializing with invalid mode falls back to suggest."""
+        handler = AutonomyModeHandler()
+        manager = handler.initialize(mode="invalid_mode")
+        
+        assert manager.mode == AutonomyMode.SUGGEST
+    
+    def test_get_manager(self):
+        """Test getting manager."""
+        handler = AutonomyModeHandler()
+        
+        assert handler.get_manager() is None
+        
+        handler.initialize()
+        assert handler.get_manager() is not None
+    
+    def test_request_approval(self):
+        """Test requesting approval through handler."""
+        handler = AutonomyModeHandler()
+        handler.initialize(mode="full_auto")
+        
+        action = ActionRequest(ActionType.FILE_WRITE, "Write file")
+        result = handler.request_approval(action)
+        
+        assert result.approved is True
+    
+    def test_set_mode(self):
+        """Test setting mode through handler."""
+        handler = AutonomyModeHandler()
+        handler.initialize(mode="suggest")
+        
+        handler.set_mode("auto_edit")
+        
+        assert handler.get_mode() == "auto_edit"
+    
+    def test_get_mode(self):
+        """Test getting mode through handler."""
+        handler = AutonomyModeHandler()
+        
+        # Before initialization
+        assert handler.get_mode() == "suggest"
+        
+        handler.initialize(mode="full_auto")
+        assert handler.get_mode() == "full_auto"
+
+
+# ============================================================================
+# Convenience Function Tests
+# ============================================================================
+
+class TestConvenienceFunctions:
+    """Tests for convenience functions."""
+    
+    def test_create_file_write_action(self):
+        """Test creating file write action."""
+        action = create_file_write_action("/path/to/file.py", "content preview")
+        
+        assert action.action_type == ActionType.FILE_WRITE
+        assert "/path/to/file.py" in action.description
+        assert action.details["path"] == "/path/to/file.py"
+        assert action.risk_level == "medium"
+        assert action.reversible is True
+    
+    def test_create_shell_command_action(self):
+        """Test creating shell command action."""
+        action = create_shell_command_action("pytest tests/", "/project")
+        
+        assert action.action_type == ActionType.SHELL_COMMAND
+        assert action.details["command"] == "pytest tests/"
+        assert action.details["cwd"] == "/project"
+        assert action.risk_level == "medium"
+        assert action.reversible is False
+    
+    def test_create_shell_command_dangerous(self):
+        """Test dangerous shell command has high risk."""
+        action = create_shell_command_action("rm -rf /")
+        
+        assert action.risk_level == "high"
+    
+    def test_create_git_action(self):
+        """Test creating git action."""
+        action = create_git_action("commit", {"message": "Fix bug"})
+        
+        assert action.action_type == ActionType.GIT_OPERATION
+        assert "commit" in action.description
+        assert action.details["message"] == "Fix bug"
+    
+    def test_create_git_action_status_low_risk(self):
+        """Test git status has low risk."""
+        action = create_git_action("status")
+        
+        assert action.risk_level == "low"
+    
+    def test_create_tool_call_action(self):
+        """Test creating tool call action."""
+        action = create_tool_call_action("web_search", {"query": "python"})
+        
+        assert action.action_type == ActionType.TOOL_CALL
+        assert action.details["tool"] == "web_search"
+        assert action.details["args"]["query"] == "python"
+
+
+# ============================================================================
+# Integration Tests
+# ============================================================================
+
+class TestAutonomyModeIntegration:
+    """Integration tests for autonomy mode."""
+    
+    def test_full_workflow_suggest_mode(self):
+        """Test full workflow in suggest mode."""
+        approvals = []
+        
+        def track_approval(action):
+            approvals.append(action)
+            return ApprovalResult(approved=True)
+        
+        handler = AutonomyModeHandler()
+        handler.initialize(mode="suggest", approval_callback=track_approval)
+        
+        # File read should be auto-approved
+        read_action = ActionRequest(ActionType.FILE_READ, "Read file")
+        result = handler.request_approval(read_action)
+        assert result.approved is True
+        assert len(approvals) == 0  # No callback for auto-approved
+        
+        # File write should require approval
+        write_action = ActionRequest(ActionType.FILE_WRITE, "Write file")
+        result = handler.request_approval(write_action)
+        assert result.approved is True
+        assert len(approvals) == 1  # Callback was called
+    
+    def test_mode_transition(self):
+        """Test transitioning between modes."""
+        handler = AutonomyModeHandler()
+        handler.initialize(mode="suggest")
+        
+        # In suggest mode, file write requires approval
+        mock_callback = MagicMock(return_value=ApprovalResult(approved=True))
+        handler._manager.approval_callback = mock_callback
+        
+        write_action = ActionRequest(ActionType.FILE_WRITE, "Write")
+        handler.request_approval(write_action)
+        assert mock_callback.call_count == 1
+        
+        # Switch to auto-edit mode
+        handler.set_mode("auto_edit")
+        mock_callback.reset_mock()
+        
+        # Now file write should be auto-approved
+        handler.request_approval(write_action)
+        assert mock_callback.call_count == 0  # Not called

src/praisonai/tests/unit/cli/test_chat_flag.py

@@ -0,0 +1,151 @@
+"""
+Unit tests for --chat flag (alias for --chat-mode).
+
+Tests verify that:
+1. --chat flag works as an alias for --chat-mode
+2. --chat flag does not conflict with 'chat' subcommand
+3. Both flags set chat_mode=True correctly
+4. Backward compatibility with --chat-mode is maintained
+"""
+
+import sys
+import os
+import argparse
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
+
+
+class TestChatFlagParsing:
+    """Test argument parsing for --chat and --chat-mode flags."""
+    
+    def test_chat_mode_flag_sets_chat_mode_true(self):
+        """--chat-mode should set chat_mode=True."""
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--chat-mode", "--chat", action="store_true", dest="chat_mode")
+        parser.add_argument("command", nargs="?")
+        
+        args, _ = parser.parse_known_args(["--chat-mode", "test prompt"])
+        assert args.chat_mode is True
+        assert args.command == "test prompt"
+    
+    def test_chat_flag_sets_chat_mode_true(self):
+        """--chat should set chat_mode=True (alias for --chat-mode)."""
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--chat-mode", "--chat", action="store_true", dest="chat_mode")
+        parser.add_argument("command", nargs="?")
+        
+        args, _ = parser.parse_known_args(["--chat", "test prompt"])
+        assert args.chat_mode is True
+        assert args.command == "test prompt"
+    
+    def test_chat_subcommand_does_not_set_chat_mode(self):
+        """'chat' as positional command should NOT set chat_mode."""
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--chat-mode", "--chat", action="store_true", dest="chat_mode")
+        parser.add_argument("command", nargs="?")
+        
+        args, _ = parser.parse_known_args(["chat"])
+        assert args.chat_mode is False
+        assert args.command == "chat"
+    
+    def test_chat_flag_after_prompt(self):
+        """--chat after prompt should work."""
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--chat-mode", "--chat", action="store_true", dest="chat_mode")
+        parser.add_argument("command", nargs="?")
+        
+        args, _ = parser.parse_known_args(["What is 2+2?", "--chat"])
+        assert args.chat_mode is True
+        assert args.command == "What is 2+2?"
+    
+    def test_chat_mode_flag_after_prompt(self):
+        """--chat-mode after prompt should work (backward compat)."""
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--chat-mode", "--chat", action="store_true", dest="chat_mode")
+        parser.add_argument("command", nargs="?")
+        
+        args, _ = parser.parse_known_args(["What is 2+2?", "--chat-mode"])
+        assert args.chat_mode is True
+        assert args.command == "What is 2+2?"
+    
+    def test_no_flag_defaults_to_false(self):
+        """Without --chat or --chat-mode, chat_mode should be False."""
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--chat-mode", "--chat", action="store_true", dest="chat_mode")
+        parser.add_argument("command", nargs="?")
+        
+        args, _ = parser.parse_known_args(["some prompt"])
+        assert args.chat_mode is False
+        assert args.command == "some prompt"
+
+
+class TestChatFlagNoConflict:
+    """Test that --chat flag does not conflict with other features."""
+    
+    def test_chat_flag_with_other_flags(self):
+        """--chat should work alongside other flags."""
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--chat-mode", "--chat", action="store_true", dest="chat_mode")
+        parser.add_argument("--verbose", "-v", action="store_true")
+        parser.add_argument("--model", type=str)
+        parser.add_argument("command", nargs="?")
+        
+        args, _ = parser.parse_known_args(["--chat", "--verbose", "--model", "gpt-4o", "test"])
+        assert args.chat_mode is True
+        assert args.verbose is True
+        assert args.model == "gpt-4o"
+        assert args.command == "test"
+    
+    def test_chat_subcommand_with_other_flags(self):
+        """'chat' subcommand should work with other flags."""
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--chat-mode", "--chat", action="store_true", dest="chat_mode")
+        parser.add_argument("--verbose", "-v", action="store_true")
+        parser.add_argument("command", nargs="?")
+        
+        args, _ = parser.parse_known_args(["chat", "--verbose"])
+        assert args.chat_mode is False  # subcommand, not flag
+        assert args.command == "chat"
+        assert args.verbose is True
+
+
+class TestChatFlagIntegration:
+    """Integration tests with actual PraisonAI CLI parser."""
+    
+    def test_praisonai_parser_has_chat_flag(self):
+        """PraisonAI CLI should have --chat as alias for --chat-mode."""
+        # This test will fail until we implement the change
+        from praisonai.cli.main import PraisonAI
+        
+        # Create instance and get parser
+        pai = PraisonAI()
+        
+        # Mock sys.argv to avoid test environment issues
+        import sys
+        original_argv = sys.argv
+        try:
+            sys.argv = ["praisonai", "--chat", "test prompt"]
+            args = pai.parse_args()
+            assert hasattr(args, 'chat_mode')
+            # After implementation, this should be True
+            # For now, it may work due to argparse prefix matching
+        finally:
+            sys.argv = original_argv
+    
+    def test_praisonai_chat_subcommand_still_works(self):
+        """'praisonai chat' subcommand should still launch Chainlit.
+        
+        Note: In test environment, parse_args returns default args to avoid
+        pytest interference. This test verifies the parser structure instead.
+        """
+        # Test the parser structure directly without going through PraisonAI
+        # which has test environment detection
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--chat-mode", "--chat", action="store_true", dest="chat_mode")
+        parser.add_argument("command", nargs="?")
+        
+        # Simulate 'praisonai chat' - should set command='chat', not chat_mode
+        args, _ = parser.parse_known_args(["chat"])
+        assert args.command == "chat"
+        assert args.chat_mode is False  # subcommand, not flag

src/praisonai/tests/unit/cli/test_cost_tracker.py

@@ -0,0 +1,620 @@
+"""
+Tests for Cost Tracking System.
+
+Test-Driven Development approach for cost and token tracking.
+"""
+
+import pytest
+from unittest.mock import MagicMock
+from datetime import datetime, timedelta
+import json
+
+from praisonai.cli.features.cost_tracker import (
+    ModelPricing,
+    TokenUsage,
+    RequestStats,
+    SessionStats,
+    CostTracker,
+    CostTrackerHandler,
+    get_pricing,
+    DEFAULT_PRICING,
+)
+
+
+# ============================================================================
+# ModelPricing Tests
+# ============================================================================
+
+class TestModelPricing:
+    """Tests for ModelPricing dataclass."""
+    
+    def test_create_pricing(self):
+        """Test creating model pricing."""
+        pricing = ModelPricing(
+            model_name="gpt-4o",
+            input_price_per_1m=2.50,
+            output_price_per_1m=10.00
+        )
+        assert pricing.model_name == "gpt-4o"
+        assert pricing.input_price_per_1m == 2.50
+        assert pricing.output_price_per_1m == 10.00
+        assert pricing.context_window == 128000
+    
+    def test_calculate_cost(self):
+        """Test cost calculation."""
+        pricing = ModelPricing(
+            model_name="test",
+            input_price_per_1m=1.00,
+            output_price_per_1m=2.00
+        )
+        
+        # 1000 input tokens, 500 output tokens
+        cost = pricing.calculate_cost(1000, 500)
+        
+        # Expected: (1000/1M * 1.00) + (500/1M * 2.00) = 0.001 + 0.001 = 0.002
+        assert cost == pytest.approx(0.002, rel=1e-6)
+    
+    def test_calculate_cost_large_tokens(self):
+        """Test cost calculation with large token counts."""
+        pricing = ModelPricing(
+            model_name="test",
+            input_price_per_1m=2.50,
+            output_price_per_1m=10.00
+        )
+        
+        # 100K input, 50K output
+        cost = pricing.calculate_cost(100_000, 50_000)
+        
+        # Expected: (100K/1M * 2.50) + (50K/1M * 10.00) = 0.25 + 0.50 = 0.75
+        assert cost == pytest.approx(0.75, rel=1e-6)
+
+
+# ============================================================================
+# get_pricing Tests
+# ============================================================================
+
+class TestGetPricing:
+    """Tests for get_pricing function."""
+    
+    def test_get_exact_match(self):
+        """Test getting pricing with exact model name."""
+        pricing = get_pricing("gpt-4o")
+        assert pricing.model_name == "gpt-4o"
+    
+    def test_get_partial_match(self):
+        """Test getting pricing with partial model name."""
+        pricing = get_pricing("gpt-4o-2024-08-06")
+        assert "gpt-4o" in pricing.model_name.lower() or pricing == DEFAULT_PRICING["default"]
+    
+    def test_get_unknown_model(self):
+        """Test getting pricing for unknown model returns default."""
+        pricing = get_pricing("unknown-model-xyz")
+        assert pricing == DEFAULT_PRICING["default"]
+    
+    def test_default_pricing_exists(self):
+        """Test that default pricing models exist."""
+        assert "gpt-4o" in DEFAULT_PRICING
+        assert "gpt-4o-mini" in DEFAULT_PRICING
+        assert "claude-3-5-sonnet" in DEFAULT_PRICING
+        assert "gemini-2.0-flash" in DEFAULT_PRICING
+        assert "default" in DEFAULT_PRICING
+
+
+# ============================================================================
+# TokenUsage Tests
+# ============================================================================
+
+class TestTokenUsage:
+    """Tests for TokenUsage dataclass."""
+    
+    def test_create_usage(self):
+        """Test creating token usage."""
+        usage = TokenUsage(
+            input_tokens=100,
+            output_tokens=50
+        )
+        assert usage.input_tokens == 100
+        assert usage.output_tokens == 50
+        assert usage.total_tokens == 150
+        assert usage.cached_tokens == 0
+    
+    def test_usage_with_cached(self):
+        """Test usage with cached tokens."""
+        usage = TokenUsage(
+            input_tokens=100,
+            output_tokens=50,
+            cached_tokens=30
+        )
+        assert usage.cached_tokens == 30
+    
+    def test_total_tokens_auto_calculated(self):
+        """Test total tokens is auto-calculated."""
+        usage = TokenUsage(input_tokens=200, output_tokens=100)
+        assert usage.total_tokens == 300
+    
+    def test_total_tokens_explicit(self):
+        """Test explicit total tokens is preserved."""
+        usage = TokenUsage(
+            input_tokens=100,
+            output_tokens=50,
+            total_tokens=200  # Explicit value
+        )
+        assert usage.total_tokens == 200
+
+
+# ============================================================================
+# RequestStats Tests
+# ============================================================================
+
+class TestRequestStats:
+    """Tests for RequestStats dataclass."""
+    
+    def test_create_request_stats(self):
+        """Test creating request stats."""
+        usage = TokenUsage(input_tokens=100, output_tokens=50)
+        stats = RequestStats(
+            timestamp=datetime.now(),
+            model="gpt-4o",
+            usage=usage,
+            cost=0.001
+        )
+        assert stats.model == "gpt-4o"
+        assert stats.usage.total_tokens == 150
+        assert stats.cost == 0.001
+    
+    def test_to_dict(self):
+        """Test converting to dictionary."""
+        usage = TokenUsage(input_tokens=100, output_tokens=50)
+        stats = RequestStats(
+            timestamp=datetime(2024, 1, 1, 12, 0, 0),
+            model="gpt-4o",
+            usage=usage,
+            cost=0.001,
+            duration_ms=500.0
+        )
+        
+        data = stats.to_dict()
+        
+        assert data["model"] == "gpt-4o"
+        assert data["input_tokens"] == 100
+        assert data["output_tokens"] == 50
+        assert data["cost"] == 0.001
+        assert data["duration_ms"] == 500.0
+        assert "timestamp" in data
+
+
+# ============================================================================
+# SessionStats Tests
+# ============================================================================
+
+class TestSessionStats:
+    """Tests for SessionStats dataclass."""
+    
+    def test_create_session_stats(self):
+        """Test creating session stats."""
+        stats = SessionStats(
+            session_id="test-123",
+            start_time=datetime.now()
+        )
+        assert stats.session_id == "test-123"
+        assert stats.total_requests == 0
+        assert stats.total_cost == 0.0
+    
+    def test_add_request(self):
+        """Test adding request to session."""
+        session = SessionStats(
+            session_id="test",
+            start_time=datetime.now()
+        )
+        
+        usage = TokenUsage(input_tokens=100, output_tokens=50)
+        request = RequestStats(
+            timestamp=datetime.now(),
+            model="gpt-4o",
+            usage=usage,
+            cost=0.001
+        )
+        
+        session.add_request(request)
+        
+        assert session.total_requests == 1
+        assert session.total_input_tokens == 100
+        assert session.total_output_tokens == 50
+        assert session.total_tokens == 150
+        assert session.total_cost == 0.001
+        assert "gpt-4o" in session.models_used
+    
+    def test_add_multiple_requests(self):
+        """Test adding multiple requests."""
+        session = SessionStats(
+            session_id="test",
+            start_time=datetime.now()
+        )
+        
+        for i in range(3):
+            usage = TokenUsage(input_tokens=100, output_tokens=50)
+            request = RequestStats(
+                timestamp=datetime.now(),
+                model="gpt-4o",
+                usage=usage,
+                cost=0.001
+            )
+            session.add_request(request)
+        
+        assert session.total_requests == 3
+        assert session.total_tokens == 450
+        assert session.total_cost == pytest.approx(0.003)
+    
+    def test_avg_tokens_per_request(self):
+        """Test average tokens per request."""
+        session = SessionStats(
+            session_id="test",
+            start_time=datetime.now()
+        )
+        
+        for tokens in [100, 200, 300]:
+            usage = TokenUsage(input_tokens=tokens, output_tokens=0)
+            request = RequestStats(
+                timestamp=datetime.now(),
+                model="gpt-4o",
+                usage=usage,
+                cost=0.0
+            )
+            session.add_request(request)
+        
+        assert session.avg_tokens_per_request == 200.0
+    
+    def test_avg_cost_per_request(self):
+        """Test average cost per request."""
+        session = SessionStats(
+            session_id="test",
+            start_time=datetime.now()
+        )
+        
+        for cost in [0.001, 0.002, 0.003]:
+            usage = TokenUsage(input_tokens=100, output_tokens=50)
+            request = RequestStats(
+                timestamp=datetime.now(),
+                model="gpt-4o",
+                usage=usage,
+                cost=cost
+            )
+            session.add_request(request)
+        
+        assert session.avg_cost_per_request == pytest.approx(0.002)
+    
+    def test_duration_seconds(self):
+        """Test session duration calculation."""
+        start = datetime.now() - timedelta(seconds=60)
+        session = SessionStats(
+            session_id="test",
+            start_time=start
+        )
+        
+        assert session.duration_seconds >= 60
+    
+    def test_to_dict(self):
+        """Test converting to dictionary."""
+        session = SessionStats(
+            session_id="test-123",
+            start_time=datetime(2024, 1, 1, 12, 0, 0)
+        )
+        
+        data = session.to_dict()
+        
+        assert data["session_id"] == "test-123"
+        assert data["total_requests"] == 0
+        assert "start_time" in data
+
+
+# ============================================================================
+# CostTracker Tests
+# ============================================================================
+
+class TestCostTracker:
+    """Tests for CostTracker."""
+    
+    def test_create_tracker(self):
+        """Test creating cost tracker."""
+        tracker = CostTracker()
+        
+        assert tracker.session_id is not None
+        assert len(tracker.session_id) == 8
+        assert tracker.session_stats is not None
+    
+    def test_create_tracker_with_session_id(self):
+        """Test creating tracker with custom session ID."""
+        tracker = CostTracker(session_id="custom-id")
+        
+        assert tracker.session_id == "custom-id"
+    
+    def test_track_request(self):
+        """Test tracking a request."""
+        tracker = CostTracker()
+        
+        stats = tracker.track_request(
+            model="gpt-4o",
+            input_tokens=1000,
+            output_tokens=500
+        )
+        
+        assert stats is not None
+        assert stats.model == "gpt-4o"
+        assert stats.usage.input_tokens == 1000
+        assert stats.usage.output_tokens == 500
+        assert stats.cost > 0
+    
+    def test_track_multiple_requests(self):
+        """Test tracking multiple requests."""
+        tracker = CostTracker()
+        
+        tracker.track_request("gpt-4o", 1000, 500)
+        tracker.track_request("gpt-4o-mini", 2000, 1000)
+        tracker.track_request("gpt-4o", 500, 250)
+        
+        assert tracker.get_request_count() == 3
+        assert tracker.get_total_tokens() == 5250
+        assert tracker.get_total_cost() > 0
+    
+    def test_track_with_cached_tokens(self):
+        """Test tracking with cached tokens."""
+        tracker = CostTracker()
+        
+        stats = tracker.track_request(
+            model="gpt-4o",
+            input_tokens=1000,
+            output_tokens=500,
+            cached_tokens=200
+        )
+        
+        assert stats.usage.cached_tokens == 200
+        assert tracker.session_stats.total_cached_tokens == 200
+    
+    def test_track_with_duration(self):
+        """Test tracking with duration."""
+        tracker = CostTracker()
+        
+        stats = tracker.track_request(
+            model="gpt-4o",
+            input_tokens=1000,
+            output_tokens=500,
+            duration_ms=1500.0
+        )
+        
+        assert stats.duration_ms == 1500.0
+    
+    def test_get_current_stats(self):
+        """Test getting current stats."""
+        tracker = CostTracker()
+        tracker.track_request("gpt-4o", 1000, 500)
+        
+        stats = tracker.get_current_stats()
+        
+        assert stats.total_requests == 1
+        assert stats.total_tokens == 1500
+    
+    def test_format_summary(self):
+        """Test formatting summary."""
+        tracker = CostTracker(session_id="test-123")
+        tracker.track_request("gpt-4o", 1000, 500)
+        
+        summary = tracker.format_summary()
+        
+        assert "test-123" in summary
+        assert "Tokens:" in summary
+        assert "Cost:" in summary
+    
+    def test_export_json(self):
+        """Test exporting to JSON."""
+        tracker = CostTracker(session_id="test-123")
+        tracker.track_request("gpt-4o", 1000, 500)
+        
+        json_str = tracker.export_json()
+        data = json.loads(json_str)
+        
+        assert "session" in data
+        assert "requests" in data
+        assert data["session"]["session_id"] == "test-123"
+        assert len(data["requests"]) == 1
+    
+    def test_end_session(self):
+        """Test ending session."""
+        tracker = CostTracker()
+        tracker.track_request("gpt-4o", 1000, 500)
+        
+        stats = tracker.end_session()
+        
+        assert stats.end_time is not None
+    
+    def test_models_used_tracking(self):
+        """Test tracking of models used."""
+        tracker = CostTracker()
+        
+        tracker.track_request("gpt-4o", 1000, 500)
+        tracker.track_request("gpt-4o", 1000, 500)
+        tracker.track_request("gpt-4o-mini", 1000, 500)
+        
+        stats = tracker.get_current_stats()
+        
+        assert stats.models_used["gpt-4o"] == 2
+        assert stats.models_used["gpt-4o-mini"] == 1
+
+
+# ============================================================================
+# CostTracker Response Tracking Tests
+# ============================================================================
+
+class TestCostTrackerResponseTracking:
+    """Tests for tracking from LLM responses."""
+    
+    def test_track_from_openai_response(self):
+        """Test tracking from OpenAI-style response."""
+        tracker = CostTracker()
+        
+        # Mock OpenAI response
+        mock_response = MagicMock()
+        mock_response.usage = MagicMock()
+        mock_response.usage.prompt_tokens = 100
+        mock_response.usage.completion_tokens = 50
+        mock_response.usage.cached_tokens = 0
+        
+        stats = tracker.track_from_response("gpt-4o", mock_response)
+        
+        assert stats is not None
+        assert stats.usage.input_tokens == 100
+        assert stats.usage.output_tokens == 50
+    
+    def test_track_from_dict_response(self):
+        """Test tracking from dict response."""
+        tracker = CostTracker()
+        
+        response = {
+            "usage": {
+                "prompt_tokens": 200,
+                "completion_tokens": 100
+            }
+        }
+        
+        stats = tracker.track_from_response("gpt-4o", response)
+        
+        assert stats is not None
+        assert stats.usage.input_tokens == 200
+        assert stats.usage.output_tokens == 100
+    
+    def test_track_from_invalid_response(self):
+        """Test tracking from invalid response returns None."""
+        tracker = CostTracker()
+        
+        stats = tracker.track_from_response("gpt-4o", "invalid response")
+        
+        assert stats is None
+
+
+# ============================================================================
+# CostTrackerHandler Tests
+# ============================================================================
+
+class TestCostTrackerHandler:
+    """Tests for CostTrackerHandler."""
+    
+    def test_handler_creation(self):
+        """Test handler creation."""
+        handler = CostTrackerHandler()
+        assert handler.feature_name == "cost_tracker"
+    
+    def test_initialize(self):
+        """Test initializing tracker."""
+        handler = CostTrackerHandler()
+        tracker = handler.initialize()
+        
+        assert tracker is not None
+        assert handler.get_tracker() is tracker
+    
+    def test_initialize_with_session_id(self):
+        """Test initializing with session ID."""
+        handler = CostTrackerHandler()
+        tracker = handler.initialize(session_id="custom-123")
+        
+        assert tracker.session_id == "custom-123"
+    
+    def test_track_request(self):
+        """Test tracking request through handler."""
+        handler = CostTrackerHandler()
+        
+        stats = handler.track_request(
+            model="gpt-4o",
+            input_tokens=1000,
+            output_tokens=500
+        )
+        
+        assert stats is not None
+        assert handler.get_cost() > 0
+        assert handler.get_tokens() == 1500
+    
+    def test_get_summary(self):
+        """Test getting summary."""
+        handler = CostTrackerHandler()
+        handler.track_request("gpt-4o", 1000, 500)
+        
+        summary = handler.get_summary()
+        
+        assert "total_requests" in summary
+        assert summary["total_requests"] == 1
+    
+    def test_get_cost_before_init(self):
+        """Test getting cost before initialization."""
+        handler = CostTrackerHandler()
+        
+        assert handler.get_cost() == 0.0
+    
+    def test_get_tokens_before_init(self):
+        """Test getting tokens before initialization."""
+        handler = CostTrackerHandler()
+        
+        assert handler.get_tokens() == 0
+
+
+# ============================================================================
+# Integration Tests
+# ============================================================================
+
+class TestCostTrackerIntegration:
+    """Integration tests for cost tracking."""
+    
+    def test_full_session_workflow(self):
+        """Test full session workflow."""
+        handler = CostTrackerHandler(verbose=False)
+        handler.initialize(session_id="integration-test")
+        
+        # Simulate multiple requests
+        models = ["gpt-4o", "gpt-4o-mini", "gpt-4o"]
+        for i, model in enumerate(models):
+            handler.track_request(
+                model=model,
+                input_tokens=1000 * (i + 1),
+                output_tokens=500 * (i + 1),
+                duration_ms=100.0 * (i + 1)
+            )
+        
+        # Verify totals
+        summary = handler.get_summary()
+        
+        assert summary["total_requests"] == 3
+        assert summary["total_input_tokens"] == 6000  # 1000 + 2000 + 3000
+        assert summary["total_output_tokens"] == 3000  # 500 + 1000 + 1500
+        assert summary["total_tokens"] == 9000
+        assert handler.get_cost() > 0
+    
+    def test_cost_calculation_accuracy(self):
+        """Test cost calculation accuracy."""
+        tracker = CostTracker()
+        
+        # Use known pricing
+        # gpt-4o: $2.50/1M input, $10.00/1M output
+        stats = tracker.track_request(
+            model="gpt-4o",
+            input_tokens=1_000_000,  # 1M tokens
+            output_tokens=1_000_000   # 1M tokens
+        )
+        
+        # Expected: $2.50 + $10.00 = $12.50
+        assert stats.cost == pytest.approx(12.50, rel=0.01)
+    
+    def test_session_persistence(self):
+        """Test session data can be exported and contains all info."""
+        tracker = CostTracker(session_id="persist-test")
+        
+        tracker.track_request("gpt-4o", 1000, 500)
+        tracker.track_request("gpt-4o-mini", 2000, 1000)
+        
+        json_str = tracker.export_json()
+        data = json.loads(json_str)
+        
+        # Verify structure
+        assert data["session"]["session_id"] == "persist-test"
+        assert len(data["requests"]) == 2
+        assert data["session"]["total_requests"] == 2
+        
+        # Verify request details preserved
+        assert data["requests"][0]["model"] == "gpt-4o"
+        assert data["requests"][1]["model"] == "gpt-4o-mini"

src/praisonai/tests/unit/cli/test_git_integration.py

@@ -0,0 +1,368 @@
+"""
+Tests for Git Integration System.
+
+Test-Driven Development approach for Git operations.
+"""
+
+from pathlib import Path
+import tempfile
+import subprocess
+
+from praisonai.cli.features.git_integration import (
+    GitStatus,
+    GitCommit,
+    GitManager,
+    CommitMessageGenerator,
+    DiffViewer,
+    GitIntegrationHandler,
+)
+
+
+# ============================================================================
+# GitStatus Tests
+# ============================================================================
+
+class TestGitStatus:
+    """Tests for GitStatus dataclass."""
+    
+    def test_create_status(self):
+        """Test creating git status."""
+        status = GitStatus()
+        assert status.branch == ""
+        assert status.is_clean is True
+        assert status.staged_files == []
+    
+    def test_has_changes(self):
+        """Test has_changes property."""
+        status = GitStatus()
+        assert status.has_changes is False
+        
+        status.modified_files = ["file.py"]
+        assert status.has_changes is True
+
+
+# ============================================================================
+# GitCommit Tests
+# ============================================================================
+
+class TestGitCommit:
+    """Tests for GitCommit dataclass."""
+    
+    def test_create_commit(self):
+        """Test creating git commit."""
+        commit = GitCommit(
+            hash="abc123def456",
+            short_hash="abc123d",
+            message="Test commit",
+            author="Test User",
+            date="2024-01-01"
+        )
+        assert commit.hash == "abc123def456"
+        assert commit.message == "Test commit"
+
+
+# ============================================================================
+# GitManager Tests
+# ============================================================================
+
+class TestGitManager:
+    """Tests for GitManager."""
+    
+    def test_create_manager(self):
+        """Test creating git manager."""
+        manager = GitManager()
+        assert manager is not None
+    
+    def test_is_repo_false_for_non_repo(self):
+        """Test is_repo returns False for non-repo."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = GitManager(repo_path=tmpdir)
+            assert manager.is_repo is False
+    
+    def test_is_repo_true_for_repo(self):
+        """Test is_repo returns True for git repo."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Initialize git repo
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            
+            manager = GitManager(repo_path=tmpdir)
+            assert manager.is_repo is True
+    
+    def test_get_status_empty_repo(self):
+        """Test getting status of empty repo."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            
+            manager = GitManager(repo_path=tmpdir)
+            status = manager.get_status()
+            
+            assert status.is_clean is True
+    
+    def test_get_status_with_changes(self):
+        """Test getting status with changes."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            
+            # Create a file
+            (Path(tmpdir) / "test.py").write_text("# test")
+            
+            manager = GitManager(repo_path=tmpdir)
+            status = manager.get_status()
+            
+            assert "test.py" in status.untracked_files
+    
+    def test_stage_files(self):
+        """Test staging files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            (Path(tmpdir) / "test.py").write_text("# test")
+            
+            manager = GitManager(repo_path=tmpdir)
+            result = manager.stage_files(["test.py"])
+            
+            assert result is True
+            
+            status = manager.get_status()
+            assert "test.py" in status.staged_files
+    
+    def test_commit(self):
+        """Test creating a commit."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            subprocess.run(
+                ["git", "config", "user.email", "[email protected]"],
+                cwd=tmpdir, capture_output=True
+            )
+            subprocess.run(
+                ["git", "config", "user.name", "Test"],
+                cwd=tmpdir, capture_output=True
+            )
+            
+            (Path(tmpdir) / "test.py").write_text("# test")
+            
+            manager = GitManager(repo_path=tmpdir)
+            manager.stage_files()
+            
+            commit = manager.commit("Test commit")
+            
+            assert commit is not None
+            assert commit.message == "Test commit"
+    
+    def test_get_log(self):
+        """Test getting commit log."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            subprocess.run(
+                ["git", "config", "user.email", "[email protected]"],
+                cwd=tmpdir, capture_output=True
+            )
+            subprocess.run(
+                ["git", "config", "user.name", "Test"],
+                cwd=tmpdir, capture_output=True
+            )
+            
+            (Path(tmpdir) / "test.py").write_text("# test")
+            
+            manager = GitManager(repo_path=tmpdir)
+            manager.stage_files()
+            manager.commit("First commit")
+            
+            commits = manager.get_log()
+            
+            assert len(commits) >= 1
+            assert commits[0].message == "First commit"
+    
+    def test_undo_last_commit(self):
+        """Test undoing last commit."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            subprocess.run(
+                ["git", "config", "user.email", "[email protected]"],
+                cwd=tmpdir, capture_output=True
+            )
+            subprocess.run(
+                ["git", "config", "user.name", "Test"],
+                cwd=tmpdir, capture_output=True
+            )
+            
+            # Need at least 2 commits to undo one
+            (Path(tmpdir) / "test.py").write_text("# test")
+            
+            manager = GitManager(repo_path=tmpdir)
+            manager.stage_files()
+            manager.commit("First commit")
+            
+            (Path(tmpdir) / "test2.py").write_text("# test2")
+            manager.stage_files()
+            manager.commit("Second commit")
+            
+            result = manager.undo_last_commit(soft=True)
+            
+            assert result is True
+    
+    def test_get_branches(self):
+        """Test getting branches."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            subprocess.run(
+                ["git", "config", "user.email", "[email protected]"],
+                cwd=tmpdir, capture_output=True
+            )
+            subprocess.run(
+                ["git", "config", "user.name", "Test"],
+                cwd=tmpdir, capture_output=True
+            )
+            
+            (Path(tmpdir) / "test.py").write_text("# test")
+            
+            manager = GitManager(repo_path=tmpdir)
+            manager.stage_files()
+            manager.commit("Initial commit")
+            
+            branches = manager.get_branches()
+            
+            assert len(branches) >= 1
+
+
+# ============================================================================
+# CommitMessageGenerator Tests
+# ============================================================================
+
+class TestCommitMessageGenerator:
+    """Tests for CommitMessageGenerator."""
+    
+    def test_create_generator(self):
+        """Test creating generator."""
+        generator = CommitMessageGenerator()
+        assert generator is not None
+    
+    def test_generate_empty_diff(self):
+        """Test generating message for empty diff."""
+        generator = CommitMessageGenerator(use_ai=False)
+        message = generator.generate("")
+        
+        assert message == "Empty commit"
+    
+    def test_generate_from_diff(self):
+        """Test generating message from diff."""
+        generator = CommitMessageGenerator(use_ai=False)
+        
+        diff = """
+diff --git a/test.py b/test.py
+--- a/test.py
++++ b/test.py
+@@ -1 +1,5 @@
++# New content
++def hello():
++    pass
+"""
+        
+        message = generator.generate(diff)
+        
+        assert len(message) > 0
+        assert "test" in message.lower() or "feat" in message.lower()
+
+
+# ============================================================================
+# DiffViewer Tests
+# ============================================================================
+
+class TestDiffViewer:
+    """Tests for DiffViewer."""
+    
+    def test_create_viewer(self):
+        """Test creating viewer."""
+        viewer = DiffViewer()
+        assert viewer is not None
+    
+    def test_display_diff_no_console(self):
+        """Test displaying diff without console."""
+        viewer = DiffViewer()
+        viewer._console = None
+        
+        # Should not raise
+        viewer.display_diff("test diff")
+    
+    def test_display_status_no_console(self):
+        """Test displaying status without console."""
+        viewer = DiffViewer()
+        viewer._console = None
+        
+        status = GitStatus(branch="main")
+        viewer.display_status(status)
+
+
+# ============================================================================
+# GitIntegrationHandler Tests
+# ============================================================================
+
+class TestGitIntegrationHandler:
+    """Tests for GitIntegrationHandler."""
+    
+    def test_handler_creation(self):
+        """Test handler creation."""
+        handler = GitIntegrationHandler()
+        assert handler.feature_name == "git_integration"
+    
+    def test_initialize(self):
+        """Test initializing handler."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            
+            handler = GitIntegrationHandler()
+            git = handler.initialize(repo_path=tmpdir)
+            
+            assert git is not None
+            assert git.is_repo is True
+    
+    def test_show_status(self):
+        """Test showing status."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            
+            handler = GitIntegrationHandler()
+            handler.initialize(repo_path=tmpdir)
+            
+            status = handler.show_status()
+            
+            assert status is not None
+
+
+# ============================================================================
+# Integration Tests
+# ============================================================================
+
+class TestGitIntegrationIntegration:
+    """Integration tests for Git integration."""
+    
+    def test_full_workflow(self):
+        """Test full git workflow."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Initialize repo
+            subprocess.run(["git", "init"], cwd=tmpdir, capture_output=True)
+            subprocess.run(
+                ["git", "config", "user.email", "[email protected]"],
+                cwd=tmpdir, capture_output=True
+            )
+            subprocess.run(
+                ["git", "config", "user.name", "Test"],
+                cwd=tmpdir, capture_output=True
+            )
+            
+            handler = GitIntegrationHandler()
+            handler.initialize(repo_path=tmpdir)
+            
+            # Create file
+            (Path(tmpdir) / "main.py").write_text("# Main file\n")
+            
+            # Check status
+            status = handler.show_status()
+            assert "main.py" in status.untracked_files
+            
+            # Commit
+            commit = handler.commit(message="Add main.py")
+            assert commit is not None
+            
+            # Check log
+            commits = handler.show_log()
+            assert len(commits) >= 1

src/praisonai/tests/unit/cli/test_interactive_tui.py

@@ -0,0 +1,460 @@
+"""
+Tests for Interactive TUI System.
+
+Test-Driven Development approach for interactive terminal interface.
+"""
+
+from pathlib import Path
+import tempfile
+
+from praisonai.cli.features.interactive_tui import (
+    InteractiveConfig,
+    CommandCompleter,
+    HistoryManager,
+    StatusDisplay,
+    InteractiveSession,
+    InteractiveTUIHandler,
+)
+
+
+# ============================================================================
+# InteractiveConfig Tests
+# ============================================================================
+
+class TestInteractiveConfig:
+    """Tests for InteractiveConfig."""
+    
+    def test_default_config(self):
+        """Test default configuration."""
+        config = InteractiveConfig()
+        
+        assert config.prompt == ">>> "
+        assert config.multiline is True
+        assert config.enable_completions is True
+        assert config.vi_mode is False
+    
+    def test_custom_config(self):
+        """Test custom configuration."""
+        config = InteractiveConfig(
+            prompt="$ ",
+            multiline=False,
+            vi_mode=True
+        )
+        
+        assert config.prompt == "$ "
+        assert config.multiline is False
+        assert config.vi_mode is True
+
+
+# ============================================================================
+# CommandCompleter Tests
+# ============================================================================
+
+class TestCommandCompleter:
+    """Tests for CommandCompleter."""
+    
+    def test_create_completer(self):
+        """Test creating completer."""
+        completer = CommandCompleter()
+        assert completer is not None
+    
+    def test_add_commands(self):
+        """Test adding commands."""
+        completer = CommandCompleter()
+        completer.add_commands(["help", "exit", "cost"])
+        
+        assert "help" in completer.commands
+        assert "exit" in completer.commands
+    
+    def test_complete_slash_command(self):
+        """Test completing slash commands."""
+        completer = CommandCompleter(commands=["help", "history", "exit"])
+        
+        completions = completer.get_completions("/he", 3)
+        
+        assert "/help" in completions
+        # /history should also match but may be filtered
+        assert "/exit" not in completions
+    
+    def test_complete_file_mention(self):
+        """Test completing file mentions."""
+        completer = CommandCompleter()
+        completer._file_cache = ["main.py", "config.py", "utils.py"]
+        
+        completions = completer.get_completions("@main", 5)
+        
+        assert "@main.py" in completions
+    
+    def test_add_symbols(self):
+        """Test adding symbols."""
+        completer = CommandCompleter()
+        completer.add_symbols(["MyClass", "my_function"])
+        
+        assert "MyClass" in completer._symbol_cache
+    
+    def test_refresh_files(self):
+        """Test refreshing file cache."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            (Path(tmpdir) / "test.py").write_text("# test")
+            (Path(tmpdir) / "main.py").write_text("# main")
+            
+            completer = CommandCompleter()
+            completer.refresh_files(Path(tmpdir))
+            
+            assert len(completer._file_cache) >= 2
+
+
+# ============================================================================
+# HistoryManager Tests
+# ============================================================================
+
+class TestHistoryManager:
+    """Tests for HistoryManager."""
+    
+    def test_create_manager(self):
+        """Test creating history manager."""
+        manager = HistoryManager()
+        assert manager is not None
+    
+    def test_add_entry(self):
+        """Test adding history entry."""
+        manager = HistoryManager()
+        manager.add("first command")
+        manager.add("second command")
+        
+        assert len(manager.get_all()) == 2
+    
+    def test_no_duplicate_consecutive(self):
+        """Test no duplicate consecutive entries."""
+        manager = HistoryManager()
+        manager.add("same command")
+        manager.add("same command")
+        
+        assert len(manager.get_all()) == 1
+    
+    def test_get_previous(self):
+        """Test getting previous entry."""
+        manager = HistoryManager()
+        manager.add("first")
+        manager.add("second")
+        manager.add("third")
+        
+        assert manager.get_previous() == "third"
+        assert manager.get_previous() == "second"
+        assert manager.get_previous() == "first"
+    
+    def test_get_next(self):
+        """Test getting next entry."""
+        manager = HistoryManager()
+        manager.add("first")
+        manager.add("second")
+        
+        manager.get_previous()  # second
+        manager.get_previous()  # first
+        
+        assert manager.get_next() == "second"
+    
+    def test_search(self):
+        """Test searching history."""
+        manager = HistoryManager()
+        manager.add("/help")
+        manager.add("/exit")
+        manager.add("/help model")
+        
+        results = manager.search("/help")
+        
+        assert len(results) == 2
+        assert "/help" in results
+        assert "/help model" in results
+    
+    def test_clear(self):
+        """Test clearing history."""
+        manager = HistoryManager()
+        manager.add("command")
+        manager.clear()
+        
+        assert len(manager.get_all()) == 0
+    
+    def test_persistent_history(self):
+        """Test persistent history file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            history_file = Path(tmpdir) / "history.txt"
+            
+            # Create and add entries
+            manager1 = HistoryManager(history_file=str(history_file))
+            manager1.add("command1")
+            manager1.add("command2")
+            
+            # Create new manager with same file
+            manager2 = HistoryManager(history_file=str(history_file))
+            
+            assert len(manager2.get_all()) == 2
+
+
+# ============================================================================
+# StatusDisplay Tests
+# ============================================================================
+
+class TestStatusDisplay:
+    """Tests for StatusDisplay."""
+    
+    def test_create_display(self):
+        """Test creating status display."""
+        display = StatusDisplay()
+        assert display is not None
+    
+    def test_set_status(self):
+        """Test setting status."""
+        display = StatusDisplay()
+        display.set_status("model", "gpt-4o")
+        
+        assert display._status_items["model"] == "gpt-4o"
+    
+    def test_clear_status(self):
+        """Test clearing status."""
+        display = StatusDisplay()
+        display.set_status("key", "value")
+        display.clear_status("key")
+        
+        assert "key" not in display._status_items
+    
+    def test_print_welcome(self):
+        """Test printing welcome message."""
+        display = StatusDisplay()
+        display._console = None  # Force no console
+        
+        # Should not raise without console
+        display.print_welcome()
+    
+    def test_print_response(self):
+        """Test printing response."""
+        display = StatusDisplay()
+        display._console = None  # Force no console
+        
+        display.print_response("Test response")
+    
+    def test_print_error(self):
+        """Test printing error."""
+        display = StatusDisplay()
+        display._console = None  # Force no console
+        
+        display.print_error("Test error")
+
+
+# ============================================================================
+# InteractiveSession Tests
+# ============================================================================
+
+class TestInteractiveSession:
+    """Tests for InteractiveSession."""
+    
+    def test_create_session(self):
+        """Test creating session."""
+        session = InteractiveSession()
+        assert session is not None
+    
+    def test_create_session_with_config(self):
+        """Test creating session with config."""
+        config = InteractiveConfig(prompt="$ ")
+        session = InteractiveSession(config=config)
+        
+        assert session.config.prompt == "$ "
+    
+    def test_add_commands(self):
+        """Test adding commands."""
+        session = InteractiveSession()
+        session.add_commands(["help", "exit"])
+        
+        assert "help" in session.completer.commands
+    
+    def test_add_symbols(self):
+        """Test adding symbols."""
+        session = InteractiveSession()
+        session.add_symbols(["MyClass"])
+        
+        assert "MyClass" in session.completer._symbol_cache
+    
+    def test_process_empty_input(self):
+        """Test processing empty input."""
+        session = InteractiveSession()
+        result = session.process_input("")
+        
+        assert result is None
+    
+    def test_process_slash_command(self):
+        """Test processing slash command."""
+        command_called = []
+        
+        def on_command(cmd):
+            command_called.append(cmd)
+            return {"type": "help"}
+        
+        session = InteractiveSession(on_command=on_command)
+        session.process_input("/help")
+        
+        assert len(command_called) == 1
+        assert command_called[0] == "/help"
+    
+    def test_process_regular_input(self):
+        """Test processing regular input."""
+        input_received = []
+        
+        def on_input(text):
+            input_received.append(text)
+            return "Response"
+        
+        session = InteractiveSession(on_input=on_input)
+        result = session.process_input("Hello world")
+        
+        assert len(input_received) == 1
+        assert result == "Response"
+    
+    def test_exit_command_stops_session(self):
+        """Test exit command stops session."""
+        def on_command(cmd):
+            return {"type": "exit"}
+        
+        session = InteractiveSession(on_command=on_command)
+        session._running = True
+        
+        session.process_input("/exit")
+        
+        assert session._running is False
+    
+    def test_history_tracking(self):
+        """Test that input is added to history."""
+        session = InteractiveSession()
+        session.process_input("test command")
+        
+        assert "test command" in session.history.get_all()
+    
+    def test_stop_session(self):
+        """Test stopping session."""
+        session = InteractiveSession()
+        session._running = True
+        
+        session.stop()
+        
+        assert session._running is False
+
+
+# ============================================================================
+# InteractiveTUIHandler Tests
+# ============================================================================
+
+class TestInteractiveTUIHandler:
+    """Tests for InteractiveTUIHandler."""
+    
+    def test_handler_creation(self):
+        """Test handler creation."""
+        handler = InteractiveTUIHandler()
+        assert handler.feature_name == "interactive_tui"
+    
+    def test_initialize(self):
+        """Test initializing handler."""
+        handler = InteractiveTUIHandler()
+        session = handler.initialize()
+        
+        assert session is not None
+        assert handler.get_session() is session
+    
+    def test_initialize_with_config(self):
+        """Test initializing with config."""
+        handler = InteractiveTUIHandler()
+        config = InteractiveConfig(prompt="$ ")
+        
+        session = handler.initialize(config=config)
+        
+        assert session.config.prompt == "$ "
+    
+    def test_initialize_with_callbacks(self):
+        """Test initializing with callbacks."""
+        handler = InteractiveTUIHandler()
+        
+        def on_input(text):
+            return "response"
+        
+        def on_command(cmd):
+            return {"type": "help"}
+        
+        session = handler.initialize(on_input=on_input, on_command=on_command)
+        
+        assert session.on_input is on_input
+        assert session.on_command is on_command
+    
+    def test_stop(self):
+        """Test stopping handler."""
+        handler = InteractiveTUIHandler()
+        handler.initialize()
+        handler._session._running = True
+        
+        handler.stop()
+        
+        assert handler._session._running is False
+
+
+# ============================================================================
+# Integration Tests
+# ============================================================================
+
+class TestInteractiveTUIIntegration:
+    """Integration tests for Interactive TUI."""
+    
+    def test_full_session_workflow(self):
+        """Test full session workflow."""
+        
+        def on_input(text):
+            return f"Echo: {text}"
+        
+        def on_command(cmd):
+            if cmd == "/exit":
+                return {"type": "exit"}
+            return {"type": "command", "message": f"Executed: {cmd}"}
+        
+        handler = InteractiveTUIHandler()
+        session = handler.initialize(on_input=on_input, on_command=on_command)
+        
+        # Process various inputs
+        result1 = session.process_input("Hello")
+        assert result1 == "Echo: Hello"
+        
+        result2 = session.process_input("/help")
+        assert result2 == "Executed: /help"
+        
+        # Exit
+        session.process_input("/exit")
+        assert session._running is False
+    
+    def test_completion_integration(self):
+        """Test completion integration."""
+        handler = InteractiveTUIHandler()
+        session = handler.initialize()
+        
+        # Add commands and symbols
+        session.add_commands(["help", "exit", "cost"])
+        session.add_symbols(["MyClass", "my_function"])
+        
+        # Test completions
+        completions = session.completer.get_completions("/he", 3)
+        assert "/help" in completions
+        
+        completions = session.completer.get_completions("My", 2)
+        assert "MyClass" in completions
+    
+    def test_history_integration(self):
+        """Test history integration."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            history_file = Path(tmpdir) / "history.txt"
+            
+            config = InteractiveConfig(history_file=str(history_file))
+            handler = InteractiveTUIHandler()
+            session = handler.initialize(config=config)
+            
+            # Add some history
+            session.process_input("command 1")
+            session.process_input("command 2")
+            
+            # Check history
+            history = session.history.get_all()
+            assert "command 1" in history
+            assert "command 2" in history

src/praisonai/tests/unit/cli/test_message_queue.py

@@ -0,0 +1,661 @@
+"""
+Unit tests for Message Queue feature.
+
+Tests for:
+1. MessageQueue - FIFO queue for messages
+2. ProcessingState - State management
+3. QueuedMessage - Message with metadata
+4. MessageQueueHandler - Main handler class
+"""
+
+import time
+import threading
+
+
+# ============================================================================
+# 1. MessageQueue Tests - FIFO operations
+# ============================================================================
+
+class TestMessageQueue:
+    """Test MessageQueue FIFO operations."""
+    
+    def test_create_empty_queue(self):
+        """Queue should start empty."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        assert queue.is_empty
+        assert queue.count == 0
+    
+    def test_add_message(self):
+        """Should add message to queue."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        queue.add("Hello")
+        assert not queue.is_empty
+        assert queue.count == 1
+    
+    def test_add_multiple_messages(self):
+        """Should add multiple messages in order."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        queue.add("First")
+        queue.add("Second")
+        queue.add("Third")
+        assert queue.count == 3
+    
+    def test_pop_message_fifo(self):
+        """Should pop messages in FIFO order."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        queue.add("First")
+        queue.add("Second")
+        msg = queue.pop()
+        assert msg == "First"
+        assert queue.count == 1
+    
+    def test_pop_empty_queue(self):
+        """Should return None when popping empty queue."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        msg = queue.pop()
+        assert msg is None
+    
+    def test_peek_message(self):
+        """Should peek without removing."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        queue.add("First")
+        queue.add("Second")
+        msg = queue.peek()
+        assert msg == "First"
+        assert queue.count == 2  # Not removed
+    
+    def test_peek_empty_queue(self):
+        """Should return None when peeking empty queue."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        msg = queue.peek()
+        assert msg is None
+    
+    def test_clear_queue(self):
+        """Should clear all messages."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        queue.add("First")
+        queue.add("Second")
+        queue.clear()
+        assert queue.is_empty
+        assert queue.count == 0
+    
+    def test_get_all_messages(self):
+        """Should get all messages as list."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        queue.add("First")
+        queue.add("Second")
+        messages = queue.get_all()
+        assert messages == ["First", "Second"]
+        assert queue.count == 2  # Not removed
+    
+    def test_remove_at_index(self):
+        """Should remove message at specific index."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        queue.add("First")
+        queue.add("Second")
+        queue.add("Third")
+        removed = queue.remove_at(1)
+        assert removed == "Second"
+        assert queue.count == 2
+        assert queue.get_all() == ["First", "Third"]
+    
+    def test_remove_at_invalid_index(self):
+        """Should return None for invalid index."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        queue.add("First")
+        removed = queue.remove_at(5)
+        assert removed is None
+        assert queue.count == 1
+    
+    def test_add_empty_message_ignored(self):
+        """Should ignore empty messages."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        queue.add("")
+        queue.add("   ")
+        assert queue.is_empty
+    
+    def test_thread_safety(self):
+        """Queue should be thread-safe."""
+        from praisonai.cli.features.message_queue import MessageQueue
+        queue = MessageQueue()
+        results = []
+        
+        def add_messages():
+            for i in range(100):
+                queue.add(f"msg-{i}")
+        
+        def pop_messages():
+            for _ in range(100):
+                msg = queue.pop()
+                if msg:
+                    results.append(msg)
+        
+        t1 = threading.Thread(target=add_messages)
+        t2 = threading.Thread(target=pop_messages)
+        t1.start()
+        t2.start()
+        t1.join()
+        t2.join()
+        
+        # All messages should be accounted for
+        total = len(results) + queue.count
+        assert total == 100
+
+
+# ============================================================================
+# 2. ProcessingState Tests
+# ============================================================================
+
+class TestProcessingState:
+    """Test ProcessingState enum and state management."""
+    
+    def test_state_enum_values(self):
+        """Should have correct state values."""
+        from praisonai.cli.features.message_queue import ProcessingState
+        assert ProcessingState.IDLE.value == "idle"
+        assert ProcessingState.PROCESSING.value == "processing"
+        assert ProcessingState.WAITING_APPROVAL.value == "waiting_approval"
+    
+    def test_state_manager_initial_state(self):
+        """Should start in IDLE state."""
+        from praisonai.cli.features.message_queue import StateManager, ProcessingState
+        manager = StateManager()
+        assert manager.current_state == ProcessingState.IDLE
+    
+    def test_state_transition(self):
+        """Should transition between states."""
+        from praisonai.cli.features.message_queue import StateManager, ProcessingState
+        manager = StateManager()
+        manager.set_state(ProcessingState.PROCESSING)
+        assert manager.current_state == ProcessingState.PROCESSING
+    
+    def test_is_idle(self):
+        """Should correctly report idle state."""
+        from praisonai.cli.features.message_queue import StateManager, ProcessingState
+        manager = StateManager()
+        assert manager.is_idle
+        manager.set_state(ProcessingState.PROCESSING)
+        assert not manager.is_idle
+    
+    def test_is_processing(self):
+        """Should correctly report processing state."""
+        from praisonai.cli.features.message_queue import StateManager, ProcessingState
+        manager = StateManager()
+        assert not manager.is_processing
+        manager.set_state(ProcessingState.PROCESSING)
+        assert manager.is_processing
+    
+    def test_state_callback(self):
+        """Should call callback on state change."""
+        from praisonai.cli.features.message_queue import StateManager, ProcessingState
+        callback_called = []
+        
+        def on_state_change(old_state, new_state):
+            callback_called.append((old_state, new_state))
+        
+        manager = StateManager(on_state_change=on_state_change)
+        manager.set_state(ProcessingState.PROCESSING)
+        
+        assert len(callback_called) == 1
+        assert callback_called[0] == (ProcessingState.IDLE, ProcessingState.PROCESSING)
+
+
+# ============================================================================
+# 3. QueuedMessage Tests
+# ============================================================================
+
+class TestQueuedMessage:
+    """Test QueuedMessage dataclass."""
+    
+    def test_create_queued_message(self):
+        """Should create message with content."""
+        from praisonai.cli.features.message_queue import QueuedMessage
+        msg = QueuedMessage(content="Hello")
+        assert msg.content == "Hello"
+        assert msg.timestamp is not None
+    
+    def test_message_has_timestamp(self):
+        """Should have creation timestamp."""
+        from praisonai.cli.features.message_queue import QueuedMessage
+        before = time.time()
+        msg = QueuedMessage(content="Hello")
+        after = time.time()
+        assert before <= msg.timestamp <= after
+    
+    def test_message_priority(self):
+        """Should support priority levels."""
+        from praisonai.cli.features.message_queue import QueuedMessage, MessagePriority
+        msg = QueuedMessage(content="Hello", priority=MessagePriority.HIGH)
+        assert msg.priority == MessagePriority.HIGH
+    
+    def test_default_priority_normal(self):
+        """Should default to NORMAL priority."""
+        from praisonai.cli.features.message_queue import QueuedMessage, MessagePriority
+        msg = QueuedMessage(content="Hello")
+        assert msg.priority == MessagePriority.NORMAL
+
+
+# ============================================================================
+# 4. MessageQueueHandler Tests
+# ============================================================================
+
+class TestMessageQueueHandler:
+    """Test MessageQueueHandler main class."""
+    
+    def test_handler_creation(self):
+        """Should create handler with default settings."""
+        from praisonai.cli.features.message_queue import MessageQueueHandler
+        handler = MessageQueueHandler()
+        assert handler.queue.is_empty
+        assert handler.state_manager.is_idle
+    
+    def test_submit_when_idle(self):
+        """Should process immediately when idle."""
+        from praisonai.cli.features.message_queue import MessageQueueHandler
+        processed = []
+        
+        def processor(msg):
+            processed.append(msg)
+            return f"Response to: {msg}"
+        
+        handler = MessageQueueHandler(processor=processor)
+        handler.submit("Hello")
+        
+        # Should process immediately
+        assert "Hello" in processed
+    
+    def test_queue_when_processing(self):
+        """Should queue message when already processing."""
+        from praisonai.cli.features.message_queue import MessageQueueHandler, ProcessingState
+        
+        handler = MessageQueueHandler()
+        handler.state_manager.set_state(ProcessingState.PROCESSING)
+        handler.submit("Hello")
+        
+        # Should be queued, not processed
+        assert handler.queue.count == 1
+    
+    def test_auto_process_queue_on_idle(self):
+        """Should auto-process queue when becoming idle."""
+        from praisonai.cli.features.message_queue import MessageQueueHandler, ProcessingState
+        processed = []
+        
+        def processor(msg):
+            processed.append(msg)
+            return f"Response: {msg}"
+        
+        handler = MessageQueueHandler(processor=processor)
+        
+        # Simulate processing state
+        handler.state_manager.set_state(ProcessingState.PROCESSING)
+        handler.submit("Queued1")
+        handler.submit("Queued2")
+        
+        assert handler.queue.count == 2
+        
+        # Simulate becoming idle - should trigger queue processing
+        handler.on_processing_complete()
+        
+        # Queue should be processed
+        assert "Queued1" in processed or handler.queue.count < 2
+    
+    def test_get_queue_status(self):
+        """Should return queue status."""
+        from praisonai.cli.features.message_queue import MessageQueueHandler, ProcessingState
+        handler = MessageQueueHandler()
+        handler.state_manager.set_state(ProcessingState.PROCESSING)
+        handler.submit("Hello")
+        handler.submit("World")
+        
+        status = handler.get_status()
+        assert status['queue_count'] == 2
+        assert status['state'] == 'processing'
+    
+    def test_clear_queue(self):
+        """Should clear queue via handler."""
+        from praisonai.cli.features.message_queue import MessageQueueHandler, ProcessingState
+        handler = MessageQueueHandler()
+        handler.state_manager.set_state(ProcessingState.PROCESSING)
+        handler.submit("Hello")
+        handler.clear_queue()
+        assert handler.queue.is_empty
+
+
+# ============================================================================
+# 5. QueueDisplay Tests
+# ============================================================================
+
+class TestQueueDisplay:
+    """Test QueueDisplay for visual indicators."""
+    
+    def test_format_empty_queue(self):
+        """Should return empty string for empty queue."""
+        from praisonai.cli.features.message_queue import QueueDisplay, MessageQueue
+        queue = MessageQueue()
+        display = QueueDisplay(queue)
+        assert display.format_queue() == ""
+    
+    def test_format_single_message(self):
+        """Should format single message."""
+        from praisonai.cli.features.message_queue import QueueDisplay, MessageQueue
+        queue = MessageQueue()
+        queue.add("Hello world")
+        display = QueueDisplay(queue)
+        formatted = display.format_queue()
+        assert "↳" in formatted
+        assert "Hello world" in formatted
+    
+    def test_format_multiple_messages(self):
+        """Should format multiple messages."""
+        from praisonai.cli.features.message_queue import QueueDisplay, MessageQueue
+        queue = MessageQueue()
+        queue.add("First")
+        queue.add("Second")
+        display = QueueDisplay(queue)
+        formatted = display.format_queue()
+        assert "First" in formatted
+        assert "Second" in formatted
+    
+    def test_truncate_long_message(self):
+        """Should truncate long messages."""
+        from praisonai.cli.features.message_queue import QueueDisplay, MessageQueue
+        queue = MessageQueue()
+        queue.add("A" * 100)
+        display = QueueDisplay(queue, max_message_length=20)
+        formatted = display.format_queue()
+        assert "..." in formatted
+    
+    def test_format_status_idle(self):
+        """Should show idle status."""
+        from praisonai.cli.features.message_queue import QueueDisplay, MessageQueue, StateManager
+        queue = MessageQueue()
+        state = StateManager()
+        display = QueueDisplay(queue, state_manager=state)
+        status = display.format_status()
+        assert "idle" in status.lower() or status == ""
+    
+    def test_format_status_processing(self):
+        """Should show processing status."""
+        from praisonai.cli.features.message_queue import (
+            QueueDisplay, MessageQueue, StateManager, ProcessingState
+        )
+        queue = MessageQueue()
+        state = StateManager()
+        state.set_state(ProcessingState.PROCESSING)
+        display = QueueDisplay(queue, state_manager=state)
+        status = display.format_status()
+        assert "processing" in status.lower() or "⏳" in status
+    
+    def test_format_queue_count(self):
+        """Should show queue count."""
+        from praisonai.cli.features.message_queue import QueueDisplay, MessageQueue, ProcessingState, StateManager
+        queue = MessageQueue()
+        queue.add("First")
+        queue.add("Second")
+        state = StateManager()
+        state.set_state(ProcessingState.PROCESSING)
+        display = QueueDisplay(queue, state_manager=state)
+        count_str = display.format_queue_count()
+        assert "2" in count_str
+
+
+# ============================================================================
+# 6. Integration Tests
+# ============================================================================
+
+class TestMessageQueueIntegration:
+    """Integration tests for message queue system."""
+    
+    def test_full_workflow(self):
+        """Test complete queue workflow."""
+        from praisonai.cli.features.message_queue import (
+            MessageQueueHandler, ProcessingState
+        )
+        
+        results = []
+        
+        def processor(msg):
+            results.append(msg)
+            return f"Processed: {msg}"
+        
+        handler = MessageQueueHandler(processor=processor)
+        
+        # 1. Submit when idle - processes immediately
+        handler.submit("First")
+        assert "First" in results
+        
+        # 2. Simulate processing
+        handler.state_manager.set_state(ProcessingState.PROCESSING)
+        
+        # 3. Queue messages while processing
+        handler.submit("Second")
+        handler.submit("Third")
+        assert handler.queue.count == 2
+        
+        # 4. Complete processing - should auto-process queue
+        handler.on_processing_complete()
+        
+        # Queue should be processed
+        assert handler.queue.count < 2 or "Second" in results
+    
+    def test_queue_with_display(self):
+        """Test queue with display formatting."""
+        from praisonai.cli.features.message_queue import (
+            MessageQueueHandler, QueueDisplay, ProcessingState
+        )
+        
+        handler = MessageQueueHandler()
+        handler.state_manager.set_state(ProcessingState.PROCESSING)
+        handler.submit("Task 1")
+        handler.submit("Task 2")
+        
+        display = QueueDisplay(handler.queue, state_manager=handler.state_manager)
+        
+        # Should show processing status
+        status = display.format_status()
+        assert "processing" in status.lower() or "⏳" in status
+        
+        # Should show queued messages
+        queue_str = display.format_queue()
+        assert "Task 1" in queue_str
+        assert "Task 2" in queue_str
+
+
+# ============================================================================
+# 9. AsyncProcessor Tests - Background processing
+# ============================================================================
+
+class TestAsyncProcessor:
+    """Test AsyncProcessor for background agent execution."""
+    
+    def test_processor_creation(self):
+        """Should create processor with callback."""
+        from praisonai.cli.features.message_queue import AsyncProcessor
+        
+        results = []
+        def on_complete(result):
+            results.append(result)
+        
+        processor = AsyncProcessor(on_complete=on_complete)
+        assert processor is not None
+    
+    def test_start_processing(self):
+        """Should start processing in background thread."""
+        from praisonai.cli.features.message_queue import AsyncProcessor
+        import time
+        
+        results = []
+        def work_fn():
+            time.sleep(0.05)
+            return "done"
+        
+        def on_complete(result):
+            results.append(result)
+        
+        processor = AsyncProcessor(on_complete=on_complete)
+        processor.start(work_fn)
+        
+        # Should be processing
+        assert processor.is_running
+        
+        # Wait for completion
+        time.sleep(0.15)
+        assert not processor.is_running
+        assert "done" in results
+    
+    def test_is_running_property(self):
+        """Should track running state."""
+        from praisonai.cli.features.message_queue import AsyncProcessor
+        import time
+        
+        def slow_work():
+            time.sleep(0.1)
+            return "result"
+        
+        processor = AsyncProcessor()
+        assert not processor.is_running
+        
+        processor.start(slow_work)
+        assert processor.is_running
+        
+        time.sleep(0.15)
+        assert not processor.is_running
+    
+    def test_on_status_callback(self):
+        """Should call status callback during processing."""
+        from praisonai.cli.features.message_queue import AsyncProcessor
+        import time
+        
+        statuses = []
+        def on_status(status):
+            statuses.append(status)
+        
+        def work_with_status(status_callback):
+            status_callback("Starting...")
+            time.sleep(0.02)
+            status_callback("Working...")
+            return "done"
+        
+        processor = AsyncProcessor(on_status=on_status)
+        processor.start(lambda: work_with_status(on_status))
+        
+        time.sleep(0.1)
+        assert len(statuses) >= 1
+
+
+# ============================================================================
+# 10. LiveStatusDisplay Tests - Real-time status
+# ============================================================================
+
+class TestLiveStatusDisplay:
+    """Test LiveStatusDisplay for real-time tool/command status."""
+    
+    def test_display_creation(self):
+        """Should create display."""
+        from praisonai.cli.features.message_queue import LiveStatusDisplay
+        
+        display = LiveStatusDisplay()
+        assert display is not None
+    
+    def test_update_status(self):
+        """Should update current status."""
+        from praisonai.cli.features.message_queue import LiveStatusDisplay
+        
+        display = LiveStatusDisplay()
+        display.update_status("Processing...")
+        assert display.current_status == "Processing..."
+    
+    def test_add_tool_call(self):
+        """Should track tool calls."""
+        from praisonai.cli.features.message_queue import LiveStatusDisplay
+        
+        display = LiveStatusDisplay()
+        display.add_tool_call("read_file", {"path": "test.py"})
+        
+        assert len(display.tool_calls) == 1
+        assert display.tool_calls[0]['name'] == "read_file"
+    
+    def test_add_command_execution(self):
+        """Should track command executions."""
+        from praisonai.cli.features.message_queue import LiveStatusDisplay
+        
+        display = LiveStatusDisplay()
+        display.add_command("ls -la")
+        
+        assert len(display.commands) == 1
+        assert display.commands[0] == "ls -la"
+    
+    def test_format_live_status(self):
+        """Should format live status for display."""
+        from praisonai.cli.features.message_queue import LiveStatusDisplay
+        
+        display = LiveStatusDisplay()
+        display.update_status("Thinking...")
+        display.add_tool_call("read_file", {"path": "main.py"})
+        
+        formatted = display.format()
+        assert "Thinking" in formatted or "read_file" in formatted
+    
+    def test_clear_status(self):
+        """Should clear all status."""
+        from praisonai.cli.features.message_queue import LiveStatusDisplay
+        
+        display = LiveStatusDisplay()
+        display.update_status("Working")
+        display.add_tool_call("test", {})
+        display.add_command("echo hi")
+        
+        display.clear()
+        
+        assert display.current_status == ""
+        assert len(display.tool_calls) == 0
+        assert len(display.commands) == 0
+
+
+# ============================================================================
+# 11. NonBlockingInput Tests - Async input handling
+# ============================================================================
+
+class TestNonBlockingInput:
+    """Test NonBlockingInput for async user input."""
+    
+    def test_input_handler_creation(self):
+        """Should create input handler."""
+        from praisonai.cli.features.message_queue import NonBlockingInput
+        
+        handler = NonBlockingInput()
+        assert handler is not None
+    
+    def test_submit_input(self):
+        """Should accept input while processing."""
+        from praisonai.cli.features.message_queue import NonBlockingInput
+        
+        handler = NonBlockingInput()
+        handler.submit("new message")
+        
+        assert handler.has_pending
+        assert handler.pop() == "new message"
+    
+    def test_multiple_inputs(self):
+        """Should queue multiple inputs."""
+        from praisonai.cli.features.message_queue import NonBlockingInput
+        
+        handler = NonBlockingInput()
+        handler.submit("first")
+        handler.submit("second")
+        
+        assert handler.pending_count == 2
+        assert handler.pop() == "first"
+        assert handler.pop() == "second"

src/praisonai/tests/unit/cli/test_repo_map.py

@@ -0,0 +1,611 @@
+"""
+Tests for Repository Map System.
+
+Test-Driven Development approach for codebase mapping.
+"""
+
+import pytest
+from pathlib import Path
+import tempfile
+
+from praisonai.cli.features.repo_map import (
+    Symbol,
+    FileMap,
+    RepoMapConfig,
+    SymbolExtractor,
+    SymbolRanker,
+    RepoMap,
+    RepoMapHandler,
+)
+
+
+# ============================================================================
+# Symbol Tests
+# ============================================================================
+
+class TestSymbol:
+    """Tests for Symbol dataclass."""
+    
+    def test_create_symbol(self):
+        """Test creating a symbol."""
+        symbol = Symbol(
+            name="MyClass",
+            kind="class",
+            file_path="test.py",
+            line_number=10
+        )
+        assert symbol.name == "MyClass"
+        assert symbol.kind == "class"
+        assert symbol.file_path == "test.py"
+        assert symbol.line_number == 10
+    
+    def test_symbol_with_signature(self):
+        """Test symbol with signature."""
+        symbol = Symbol(
+            name="my_function",
+            kind="function",
+            file_path="test.py",
+            line_number=5,
+            signature="def my_function(x, y):"
+        )
+        assert symbol.signature == "def my_function(x, y):"
+    
+    def test_symbol_with_parent(self):
+        """Test method symbol with parent class."""
+        symbol = Symbol(
+            name="method",
+            kind="method",
+            file_path="test.py",
+            line_number=15,
+            parent="MyClass"
+        )
+        assert symbol.parent == "MyClass"
+        assert symbol.qualified_name == "MyClass.method"
+    
+    def test_symbol_qualified_name_no_parent(self):
+        """Test qualified name without parent."""
+        symbol = Symbol(
+            name="function",
+            kind="function",
+            file_path="test.py",
+            line_number=1
+        )
+        assert symbol.qualified_name == "function"
+    
+    def test_symbol_hash(self):
+        """Test symbol hashing for sets."""
+        s1 = Symbol("test", "function", "file.py", 1)
+        s2 = Symbol("test", "function", "file.py", 1)
+        s3 = Symbol("test", "function", "file.py", 2)
+        
+        assert hash(s1) == hash(s2)
+        assert hash(s1) != hash(s3)
+
+
+# ============================================================================
+# FileMap Tests
+# ============================================================================
+
+class TestFileMap:
+    """Tests for FileMap dataclass."""
+    
+    def test_create_file_map(self):
+        """Test creating a file map."""
+        file_map = FileMap(file_path="test.py")
+        assert file_map.file_path == "test.py"
+        assert file_map.symbols == []
+    
+    def test_add_symbol(self):
+        """Test adding symbols to file map."""
+        file_map = FileMap(file_path="test.py")
+        symbol = Symbol("test", "function", "test.py", 1)
+        
+        file_map.add_symbol(symbol)
+        
+        assert len(file_map.symbols) == 1
+        assert file_map.symbols[0].name == "test"
+    
+    def test_get_summary(self):
+        """Test getting file summary."""
+        file_map = FileMap(file_path="test.py")
+        file_map.add_symbol(Symbol(
+            "MyClass", "class", "test.py", 1,
+            signature="class MyClass:"
+        ))
+        file_map.add_symbol(Symbol(
+            "my_func", "function", "test.py", 10,
+            signature="def my_func(x):"
+        ))
+        
+        summary = file_map.get_summary()
+        
+        assert "test.py:" in summary
+        assert "class MyClass:" in summary or "MyClass" in summary
+
+
+# ============================================================================
+# RepoMapConfig Tests
+# ============================================================================
+
+class TestRepoMapConfig:
+    """Tests for RepoMapConfig."""
+    
+    def test_default_config(self):
+        """Test default configuration."""
+        config = RepoMapConfig()
+        
+        assert config.max_tokens == 1024
+        assert config.max_files == 50
+        assert ".py" in config.file_extensions
+        assert "__pycache__" in config.exclude_patterns
+    
+    def test_custom_config(self):
+        """Test custom configuration."""
+        config = RepoMapConfig(
+            max_tokens=2048,
+            max_files=100,
+            file_extensions={".py", ".js"}
+        )
+        
+        assert config.max_tokens == 2048
+        assert config.max_files == 100
+        assert len(config.file_extensions) == 2
+
+
+# ============================================================================
+# SymbolExtractor Tests
+# ============================================================================
+
+class TestSymbolExtractor:
+    """Tests for SymbolExtractor."""
+    
+    def test_create_extractor(self):
+        """Test creating extractor."""
+        extractor = SymbolExtractor(use_tree_sitter=False)
+        assert extractor is not None
+    
+    def test_extract_python_class(self):
+        """Test extracting Python class."""
+        extractor = SymbolExtractor(use_tree_sitter=False)
+        
+        content = """
+class MyClass:
+    def __init__(self):
+        pass
+    
+    def method(self):
+        pass
+"""
+        
+        symbols = extractor.extract_symbols("test.py", content)
+        
+        class_symbols = [s for s in symbols if s.kind == "class"]
+        assert len(class_symbols) >= 1
+        assert class_symbols[0].name == "MyClass"
+    
+    def test_extract_python_function(self):
+        """Test extracting Python function."""
+        extractor = SymbolExtractor(use_tree_sitter=False)
+        
+        content = """
+def my_function(x, y):
+    return x + y
+
+def another_function():
+    pass
+"""
+        
+        symbols = extractor.extract_symbols("test.py", content)
+        
+        func_symbols = [s for s in symbols if s.kind == "function"]
+        assert len(func_symbols) >= 2
+        names = [s.name for s in func_symbols]
+        assert "my_function" in names
+        assert "another_function" in names
+    
+    def test_extract_python_method(self):
+        """Test extracting Python method."""
+        extractor = SymbolExtractor(use_tree_sitter=False)
+        
+        content = """
+class MyClass:
+    def method_one(self):
+        pass
+    
+    def method_two(self, x):
+        return x
+"""
+        
+        symbols = extractor.extract_symbols("test.py", content)
+        
+        method_symbols = [s for s in symbols if s.kind == "method"]
+        assert len(method_symbols) >= 2
+        
+        # Check parent is set
+        for method in method_symbols:
+            assert method.parent == "MyClass"
+    
+    def test_extract_javascript_class(self):
+        """Test extracting JavaScript class."""
+        extractor = SymbolExtractor(use_tree_sitter=False)
+        
+        content = """
+class MyComponent {
+    constructor() {}
+}
+
+export class AnotherClass {}
+"""
+        
+        symbols = extractor.extract_symbols("test.js", content)
+        
+        class_symbols = [s for s in symbols if s.kind == "class"]
+        assert len(class_symbols) >= 1
+    
+    def test_extract_javascript_function(self):
+        """Test extracting JavaScript function."""
+        extractor = SymbolExtractor(use_tree_sitter=False)
+        
+        content = """
+function myFunction() {}
+
+const arrowFunc = () => {};
+
+async function asyncFunc() {}
+"""
+        
+        symbols = extractor.extract_symbols("test.js", content)
+        
+        func_symbols = [s for s in symbols if s.kind == "function"]
+        assert len(func_symbols) >= 1
+    
+    def test_extract_go_symbols(self):
+        """Test extracting Go symbols."""
+        extractor = SymbolExtractor(use_tree_sitter=False)
+        
+        content = """
+type MyStruct struct {
+    Name string
+}
+
+func MyFunction() {}
+
+func (m *MyStruct) Method() {}
+"""
+        
+        symbols = extractor.extract_symbols("test.go", content)
+        
+        assert len(symbols) >= 2
+    
+    def test_extract_rust_symbols(self):
+        """Test extracting Rust symbols."""
+        extractor = SymbolExtractor(use_tree_sitter=False)
+        
+        content = """
+pub struct MyStruct {
+    field: i32,
+}
+
+fn my_function() {}
+
+pub async fn async_func() {}
+"""
+        
+        symbols = extractor.extract_symbols("test.rs", content)
+        
+        assert len(symbols) >= 2
+
+
+# ============================================================================
+# SymbolRanker Tests
+# ============================================================================
+
+class TestSymbolRanker:
+    """Tests for SymbolRanker."""
+    
+    def test_create_ranker(self):
+        """Test creating ranker."""
+        ranker = SymbolRanker()
+        assert ranker is not None
+    
+    def test_analyze_references(self):
+        """Test analyzing references."""
+        ranker = SymbolRanker()
+        
+        file_maps = {
+            "a.py": FileMap(
+                file_path="a.py",
+                symbols=[Symbol("MyClass", "class", "a.py", 1)]
+            ),
+            "b.py": FileMap(
+                file_path="b.py",
+                symbols=[Symbol("use_class", "function", "b.py", 1)]
+            )
+        }
+        
+        all_content = {
+            "a.py": "class MyClass:\n    pass",
+            "b.py": "from a import MyClass\nobj = MyClass()"
+        }
+        
+        ranker.analyze_references(file_maps, all_content)
+        
+        # MyClass should have references
+        my_class = file_maps["a.py"].symbols[0]
+        assert my_class.references > 0
+    
+    def test_get_top_symbols(self):
+        """Test getting top symbols."""
+        ranker = SymbolRanker()
+        
+        file_maps = {
+            "test.py": FileMap(
+                file_path="test.py",
+                symbols=[
+                    Symbol("HighRef", "class", "test.py", 1, references=10),
+                    Symbol("LowRef", "function", "test.py", 10, references=1),
+                    Symbol("MedRef", "function", "test.py", 20, references=5),
+                ]
+            )
+        }
+        
+        # Manually set references
+        file_maps["test.py"].symbols[0].references = 10
+        file_maps["test.py"].symbols[1].references = 1
+        file_maps["test.py"].symbols[2].references = 5
+        
+        top = ranker.get_top_symbols(file_maps, max_symbols=2)
+        
+        assert len(top) == 2
+        assert top[0].name == "HighRef"
+
+
+# ============================================================================
+# RepoMap Tests
+# ============================================================================
+
+class TestRepoMap:
+    """Tests for RepoMap."""
+    
+    @pytest.fixture
+    def temp_repo(self):
+        """Create a temporary repository."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create some test files
+            (Path(tmpdir) / "main.py").write_text("""
+class Application:
+    def __init__(self):
+        self.config = Config()
+    
+    def run(self):
+        pass
+
+def main():
+    app = Application()
+    app.run()
+""")
+            
+            (Path(tmpdir) / "config.py").write_text("""
+class Config:
+    def __init__(self):
+        self.debug = False
+    
+    def load(self):
+        pass
+""")
+            
+            (Path(tmpdir) / "utils.py").write_text("""
+def helper_function():
+    pass
+
+def format_output(data):
+    return str(data)
+""")
+            
+            yield tmpdir
+    
+    def test_create_repo_map(self, temp_repo):
+        """Test creating a repo map."""
+        repo_map = RepoMap(root=temp_repo)
+        assert repo_map.root == Path(temp_repo)
+    
+    def test_scan_repository(self, temp_repo):
+        """Test scanning a repository."""
+        repo_map = RepoMap(root=temp_repo)
+        repo_map.scan()
+        
+        assert len(repo_map._file_maps) > 0
+    
+    def test_get_map(self, temp_repo):
+        """Test getting the repository map."""
+        repo_map = RepoMap(root=temp_repo)
+        map_str = repo_map.get_map()
+        
+        assert len(map_str) > 0
+        # Should contain file names
+        assert "main.py" in map_str or "config.py" in map_str
+    
+    def test_get_map_with_focus(self, temp_repo):
+        """Test getting map with focus files."""
+        repo_map = RepoMap(root=temp_repo)
+        repo_map.scan()
+        
+        map_str = repo_map.get_map(focus_files=["main.py"])
+        
+        assert "main.py" in map_str
+    
+    def test_get_file_symbols(self, temp_repo):
+        """Test getting symbols for a specific file."""
+        repo_map = RepoMap(root=temp_repo)
+        repo_map.scan()
+        
+        symbols = repo_map.get_file_symbols("main.py")
+        
+        assert len(symbols) > 0
+    
+    def test_get_symbol_context(self, temp_repo):
+        """Test getting context for a symbol."""
+        repo_map = RepoMap(root=temp_repo)
+        repo_map.scan()
+        
+        context = repo_map.get_symbol_context("Application")
+        
+        if context:  # May not find if symbol extraction differs
+            assert "Application" in context
+    
+    def test_refresh(self, temp_repo):
+        """Test refreshing the map."""
+        repo_map = RepoMap(root=temp_repo)
+        repo_map.scan()
+        
+        initial_count = len(repo_map._file_maps)
+        
+        repo_map.refresh()
+        
+        assert len(repo_map._file_maps) == initial_count
+
+
+# ============================================================================
+# RepoMapHandler Tests
+# ============================================================================
+
+class TestRepoMapHandler:
+    """Tests for RepoMapHandler."""
+    
+    @pytest.fixture
+    def temp_repo(self):
+        """Create a temporary repository."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            (Path(tmpdir) / "test.py").write_text("""
+class TestClass:
+    def test_method(self):
+        pass
+""")
+            yield tmpdir
+    
+    def test_handler_creation(self):
+        """Test handler creation."""
+        handler = RepoMapHandler()
+        assert handler.feature_name == "repo_map"
+    
+    def test_initialize(self, temp_repo):
+        """Test initializing handler."""
+        handler = RepoMapHandler()
+        repo_map = handler.initialize(root=temp_repo)
+        
+        assert repo_map is not None
+    
+    def test_get_map(self, temp_repo):
+        """Test getting map through handler."""
+        handler = RepoMapHandler()
+        handler.initialize(root=temp_repo)
+        
+        map_str = handler.get_map()
+        
+        assert len(map_str) > 0
+    
+    def test_refresh(self, temp_repo):
+        """Test refreshing through handler."""
+        handler = RepoMapHandler()
+        handler.initialize(root=temp_repo)
+        handler.get_map()
+        
+        handler.refresh()
+        
+        # Should not raise
+        map_str = handler.get_map()
+        assert len(map_str) > 0
+
+
+# ============================================================================
+# Integration Tests
+# ============================================================================
+
+class TestRepoMapIntegration:
+    """Integration tests for RepoMap."""
+    
+    @pytest.fixture
+    def complex_repo(self):
+        """Create a more complex repository."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create directory structure
+            src_dir = Path(tmpdir) / "src"
+            src_dir.mkdir()
+            
+            (src_dir / "app.py").write_text("""
+from .models import User
+from .utils import format_name
+
+class Application:
+    def __init__(self):
+        self.users = []
+    
+    def add_user(self, name):
+        user = User(format_name(name))
+        self.users.append(user)
+        return user
+    
+    def get_users(self):
+        return self.users
+""")
+            
+            (src_dir / "models.py").write_text("""
+class User:
+    def __init__(self, name):
+        self.name = name
+    
+    def __repr__(self):
+        return f"User({self.name})"
+
+class Admin(User):
+    def __init__(self, name, role):
+        super().__init__(name)
+        self.role = role
+""")
+            
+            (src_dir / "utils.py").write_text("""
+def format_name(name):
+    return name.strip().title()
+
+def validate_email(email):
+    return '@' in email
+""")
+            
+            yield tmpdir
+    
+    def test_full_scan_and_map(self, complex_repo):
+        """Test full scan and map generation."""
+        repo_map = RepoMap(root=complex_repo)
+        repo_map.scan()
+        
+        map_str = repo_map.get_map()
+        
+        # Should contain key symbols
+        assert len(map_str) > 0
+    
+    def test_symbol_ranking(self, complex_repo):
+        """Test that frequently referenced symbols rank higher."""
+        repo_map = RepoMap(root=complex_repo)
+        repo_map.scan()
+        
+        # User is referenced in multiple files
+        top_symbols = repo_map.ranker.get_top_symbols(repo_map._file_maps)
+        
+        # Should have some symbols
+        assert len(top_symbols) > 0
+    
+    def test_handler_workflow(self, complex_repo):
+        """Test complete handler workflow."""
+        handler = RepoMapHandler(verbose=False)
+        handler.initialize(root=complex_repo)
+        
+        # Get initial map
+        map1 = handler.get_map()
+        assert len(map1) > 0
+        
+        # Refresh
+        handler.refresh()
+        
+        # Get map again
+        map2 = handler.get_map()
+        assert len(map2) > 0

src/praisonai/tests/unit/cli/test_sandbox_executor.py

@@ -0,0 +1,373 @@
+"""
+Tests for Sandbox Executor System.
+
+Test-Driven Development approach for sandboxed execution.
+"""
+
+import tempfile
+
+from praisonai.cli.features.sandbox_executor import (
+    SandboxMode,
+    SandboxPolicy,
+    ExecutionResult,
+    CommandValidator,
+    SubprocessSandbox,
+    SandboxExecutorHandler,
+)
+
+
+# ============================================================================
+# SandboxMode Tests
+# ============================================================================
+
+class TestSandboxMode:
+    """Tests for SandboxMode enum."""
+    
+    def test_mode_values(self):
+        """Test mode enum values."""
+        assert SandboxMode.DISABLED.value == "disabled"
+        assert SandboxMode.BASIC.value == "basic"
+        assert SandboxMode.STRICT.value == "strict"
+        assert SandboxMode.NETWORK_ISOLATED.value == "network_isolated"
+    
+    def test_from_string_valid(self):
+        """Test parsing valid mode strings."""
+        assert SandboxMode.from_string("disabled") == SandboxMode.DISABLED
+        assert SandboxMode.from_string("basic") == SandboxMode.BASIC
+        assert SandboxMode.from_string("strict") == SandboxMode.STRICT
+    
+    def test_from_string_with_hyphen(self):
+        """Test parsing mode strings with hyphens."""
+        assert SandboxMode.from_string("network-isolated") == SandboxMode.NETWORK_ISOLATED
+    
+    def test_from_string_case_insensitive(self):
+        """Test case insensitive parsing."""
+        assert SandboxMode.from_string("BASIC") == SandboxMode.BASIC
+        assert SandboxMode.from_string("Strict") == SandboxMode.STRICT
+
+
+# ============================================================================
+# SandboxPolicy Tests
+# ============================================================================
+
+class TestSandboxPolicy:
+    """Tests for SandboxPolicy."""
+    
+    def test_default_policy(self):
+        """Test default policy."""
+        policy = SandboxPolicy()
+        
+        assert policy.mode == SandboxMode.DISABLED
+        assert policy.max_memory_mb == 512
+        assert policy.allow_network is True
+    
+    def test_for_mode_disabled(self):
+        """Test policy for disabled mode."""
+        policy = SandboxPolicy.for_mode(SandboxMode.DISABLED)
+        
+        assert policy.mode == SandboxMode.DISABLED
+    
+    def test_for_mode_basic(self):
+        """Test policy for basic mode."""
+        policy = SandboxPolicy.for_mode(SandboxMode.BASIC)
+        
+        assert policy.mode == SandboxMode.BASIC
+        assert policy.allow_network is True
+    
+    def test_for_mode_strict(self):
+        """Test policy for strict mode."""
+        policy = SandboxPolicy.for_mode(SandboxMode.STRICT)
+        
+        assert policy.mode == SandboxMode.STRICT
+        assert policy.max_memory_mb == 256
+        assert "curl" in policy.blocked_commands
+    
+    def test_for_mode_network_isolated(self):
+        """Test policy for network isolated mode."""
+        policy = SandboxPolicy.for_mode(SandboxMode.NETWORK_ISOLATED)
+        
+        assert policy.mode == SandboxMode.NETWORK_ISOLATED
+        assert policy.allow_network is False
+
+
+# ============================================================================
+# ExecutionResult Tests
+# ============================================================================
+
+class TestExecutionResult:
+    """Tests for ExecutionResult."""
+    
+    def test_create_result(self):
+        """Test creating execution result."""
+        result = ExecutionResult(
+            success=True,
+            exit_code=0,
+            stdout="output",
+            stderr="",
+            duration_ms=100.0,
+            was_sandboxed=True
+        )
+        
+        assert result.success is True
+        assert result.exit_code == 0
+        assert result.stdout == "output"
+    
+    def test_output_property(self):
+        """Test output property."""
+        result = ExecutionResult(
+            success=True,
+            exit_code=0,
+            stdout="out",
+            stderr="err",
+            duration_ms=100.0,
+            was_sandboxed=True
+        )
+        
+        assert result.output == "outerr"
+    
+    def test_policy_violations(self):
+        """Test policy violations."""
+        result = ExecutionResult(
+            success=False,
+            exit_code=-1,
+            stdout="",
+            stderr="blocked",
+            duration_ms=0.0,
+            was_sandboxed=True,
+            policy_violations=["Command blocked"]
+        )
+        
+        assert len(result.policy_violations) == 1
+
+
+# ============================================================================
+# CommandValidator Tests
+# ============================================================================
+
+class TestCommandValidator:
+    """Tests for CommandValidator."""
+    
+    def test_validate_disabled_mode(self):
+        """Test validation in disabled mode."""
+        policy = SandboxPolicy(mode=SandboxMode.DISABLED)
+        validator = CommandValidator(policy)
+        
+        violations = validator.validate("rm -rf /")
+        
+        assert len(violations) == 0  # No validation in disabled mode
+    
+    def test_validate_blocked_command(self):
+        """Test validation of blocked command."""
+        policy = SandboxPolicy(
+            mode=SandboxMode.BASIC,
+            blocked_commands={"rm", "sudo"}
+        )
+        validator = CommandValidator(policy)
+        
+        violations = validator.validate("rm file.txt")
+        
+        assert len(violations) > 0
+        assert "rm" in violations[0]
+    
+    def test_validate_dangerous_pattern(self):
+        """Test validation of dangerous patterns."""
+        policy = SandboxPolicy(mode=SandboxMode.BASIC)
+        validator = CommandValidator(policy)
+        
+        violations = validator.validate("echo test | sh")
+        
+        assert len(violations) > 0
+    
+    def test_validate_blocked_path(self):
+        """Test validation of blocked paths."""
+        policy = SandboxPolicy(
+            mode=SandboxMode.BASIC,
+            blocked_paths={"/etc", "/var"}
+        )
+        validator = CommandValidator(policy)
+        
+        violations = validator.validate("cat /etc/passwd")
+        
+        assert len(violations) > 0
+    
+    def test_is_allowed(self):
+        """Test is_allowed method."""
+        policy = SandboxPolicy(
+            mode=SandboxMode.BASIC,
+            blocked_commands={"rm"}
+        )
+        validator = CommandValidator(policy)
+        
+        assert validator.is_allowed("ls -la") is True
+        assert validator.is_allowed("rm file.txt") is False
+
+
+# ============================================================================
+# SubprocessSandbox Tests
+# ============================================================================
+
+class TestSubprocessSandbox:
+    """Tests for SubprocessSandbox."""
+    
+    def test_create_sandbox(self):
+        """Test creating sandbox."""
+        sandbox = SubprocessSandbox()
+        assert sandbox is not None
+    
+    def test_execute_disabled_mode(self):
+        """Test execution in disabled mode."""
+        policy = SandboxPolicy(mode=SandboxMode.DISABLED)
+        sandbox = SubprocessSandbox(policy=policy)
+        
+        result = sandbox.execute("echo hello")
+        
+        assert result.success is True
+        assert "hello" in result.stdout
+        assert result.was_sandboxed is False
+    
+    def test_execute_basic_mode(self):
+        """Test execution in basic mode."""
+        policy = SandboxPolicy.for_mode(SandboxMode.BASIC)
+        sandbox = SubprocessSandbox(policy=policy)
+        
+        result = sandbox.execute("echo hello")
+        
+        assert result.success is True
+        assert "hello" in result.stdout
+        assert result.was_sandboxed is True
+    
+    def test_execute_blocked_command(self):
+        """Test execution of blocked command."""
+        policy = SandboxPolicy(
+            mode=SandboxMode.BASIC,
+            blocked_commands={"rm"}
+        )
+        sandbox = SubprocessSandbox(policy=policy)
+        
+        result = sandbox.execute("rm test.txt")
+        
+        assert result.success is False
+        assert len(result.policy_violations) > 0
+    
+    def test_execute_timeout(self):
+        """Test execution timeout."""
+        policy = SandboxPolicy(mode=SandboxMode.BASIC)
+        sandbox = SubprocessSandbox(policy=policy)
+        
+        result = sandbox.execute("sleep 10", timeout=0.1)
+        
+        assert result.success is False
+        assert "timed out" in result.stderr.lower()
+    
+    def test_execute_with_working_dir(self):
+        """Test execution with working directory."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            policy = SandboxPolicy(mode=SandboxMode.BASIC)
+            sandbox = SubprocessSandbox(policy=policy, working_dir=tmpdir)
+            
+            result = sandbox.execute("pwd")
+            
+            assert result.success is True
+            assert tmpdir in result.stdout
+
+
+# ============================================================================
+# SandboxExecutorHandler Tests
+# ============================================================================
+
+class TestSandboxExecutorHandler:
+    """Tests for SandboxExecutorHandler."""
+    
+    def test_handler_creation(self):
+        """Test handler creation."""
+        handler = SandboxExecutorHandler()
+        assert handler.feature_name == "sandbox_executor"
+        assert handler.is_enabled is False
+    
+    def test_initialize_disabled(self):
+        """Test initializing with disabled mode."""
+        handler = SandboxExecutorHandler()
+        sandbox = handler.initialize(mode="disabled")
+        
+        assert sandbox is not None
+        assert handler.is_enabled is False
+    
+    def test_initialize_basic(self):
+        """Test initializing with basic mode."""
+        handler = SandboxExecutorHandler()
+        sandbox = handler.initialize(mode="basic")
+        
+        assert sandbox is not None
+        assert handler.is_enabled is True
+    
+    def test_execute(self):
+        """Test executing command."""
+        handler = SandboxExecutorHandler()
+        handler.initialize(mode="basic")
+        
+        result = handler.execute("echo test")
+        
+        assert result.success is True
+        assert "test" in result.stdout
+    
+    def test_validate_command(self):
+        """Test validating command."""
+        handler = SandboxExecutorHandler()
+        handler.initialize(mode="basic")
+        
+        violations = handler.validate_command("echo hello")
+        assert len(violations) == 0
+    
+    def test_get_mode(self):
+        """Test getting mode."""
+        handler = SandboxExecutorHandler()
+        
+        assert handler.get_mode() == "disabled"
+        
+        handler.initialize(mode="strict")
+        assert handler.get_mode() == "strict"
+
+
+# ============================================================================
+# Integration Tests
+# ============================================================================
+
+class TestSandboxIntegration:
+    """Integration tests for Sandbox."""
+    
+    def test_full_workflow_disabled(self):
+        """Test full workflow with sandbox disabled."""
+        handler = SandboxExecutorHandler()
+        handler.initialize(mode="disabled")
+        
+        # Should execute without sandboxing
+        result = handler.execute("echo hello")
+        
+        assert result.success is True
+        assert result.was_sandboxed is False
+    
+    def test_full_workflow_basic(self):
+        """Test full workflow with basic sandbox."""
+        handler = SandboxExecutorHandler()
+        handler.initialize(mode="basic")
+        
+        # Safe command should work
+        result = handler.execute("echo hello")
+        assert result.success is True
+        assert result.was_sandboxed is True
+        
+        # Blocked command should fail
+        result = handler.execute("rm -rf /")
+        assert result.success is False
+        assert len(result.policy_violations) > 0
+    
+    def test_strict_mode_isolation(self):
+        """Test strict mode isolation."""
+        handler = SandboxExecutorHandler()
+        handler.initialize(mode="strict")
+        
+        # Should work in isolated environment
+        result = handler.execute("echo $HOME")
+        
+        assert result.success is True
+        assert result.was_sandboxed is True

src/praisonai/tests/unit/cli/test_slash_commands.py

@@ -0,0 +1,608 @@
+"""
+Tests for Slash Commands System.
+
+Test-Driven Development approach:
+1. Write tests first
+2. Implement features to pass tests
+3. Refactor while keeping tests green
+"""
+
+import pytest
+from unittest.mock import MagicMock, patch
+import time
+
+from praisonai.cli.features.slash_commands import (
+    SlashCommand,
+    CommandContext,
+    CommandKind,
+    SlashCommandRegistry,
+    SlashCommandParser,
+    SlashCommandHandler,
+    create_default_registry,
+    cmd_help,
+    cmd_cost,
+    cmd_clear,
+    cmd_model,
+    cmd_tokens,
+    cmd_plan,
+    cmd_exit,
+)
+
+
+# ============================================================================
+# SlashCommand Tests
+# ============================================================================
+
+class TestSlashCommand:
+    """Tests for SlashCommand dataclass."""
+    
+    def test_create_basic_command(self):
+        """Test creating a basic slash command."""
+        cmd = SlashCommand(
+            name="test",
+            description="A test command"
+        )
+        assert cmd.name == "test"
+        assert cmd.description == "A test command"
+        assert cmd.action is None
+        assert cmd.alt_names == []
+        assert cmd.sub_commands == []
+        assert cmd.kind == CommandKind.BUILT_IN
+        assert cmd.auto_execute is True
+    
+    def test_create_command_with_action(self):
+        """Test creating a command with an action."""
+        def my_action(ctx, args):
+            return {"result": "success"}
+        
+        cmd = SlashCommand(
+            name="mycommand",
+            description="My command",
+            action=my_action
+        )
+        assert cmd.action is not None
+        result = cmd.action(None, "")
+        assert result == {"result": "success"}
+    
+    def test_create_command_with_aliases(self):
+        """Test creating a command with aliases."""
+        cmd = SlashCommand(
+            name="help",
+            description="Show help",
+            alt_names=["h", "?"]
+        )
+        assert "h" in cmd.alt_names
+        assert "?" in cmd.alt_names
+    
+    def test_create_command_with_subcommands(self):
+        """Test creating a command with sub-commands."""
+        sub1 = SlashCommand(name="sub1", description="Sub 1")
+        sub2 = SlashCommand(name="sub2", description="Sub 2")
+        
+        cmd = SlashCommand(
+            name="parent",
+            description="Parent command",
+            sub_commands=[sub1, sub2]
+        )
+        assert len(cmd.sub_commands) == 2
+        assert cmd.sub_commands[0].name == "sub1"
+    
+    def test_empty_name_raises_error(self):
+        """Test that empty name raises ValueError."""
+        with pytest.raises(ValueError, match="Command name cannot be empty"):
+            SlashCommand(name="", description="Empty name")
+    
+    def test_command_kinds(self):
+        """Test different command kinds."""
+        builtin = SlashCommand(name="builtin", description="Built-in", kind=CommandKind.BUILT_IN)
+        custom = SlashCommand(name="custom", description="Custom", kind=CommandKind.CUSTOM)
+        mcp = SlashCommand(name="mcp", description="MCP", kind=CommandKind.MCP)
+        
+        assert builtin.kind == CommandKind.BUILT_IN
+        assert custom.kind == CommandKind.CUSTOM
+        assert mcp.kind == CommandKind.MCP
+
+
+# ============================================================================
+# CommandContext Tests
+# ============================================================================
+
+class TestCommandContext:
+    """Tests for CommandContext dataclass."""
+    
+    def test_create_default_context(self):
+        """Test creating a default context."""
+        ctx = CommandContext()
+        assert ctx.agent is None
+        assert ctx.config == {}
+        assert ctx.session_id is None
+        assert ctx.total_tokens == 0
+        assert ctx.total_cost == 0.0
+        assert ctx.prompt_count == 0
+    
+    def test_context_with_metrics(self):
+        """Test context with metrics."""
+        ctx = CommandContext(
+            total_tokens=1500,
+            total_cost=0.0045,
+            prompt_count=3
+        )
+        assert ctx.total_tokens == 1500
+        assert ctx.total_cost == 0.0045
+        assert ctx.prompt_count == 3
+    
+    def test_context_with_session(self):
+        """Test context with session info."""
+        start_time = time.time()
+        ctx = CommandContext(
+            session_id="test-session-123",
+            session_start_time=start_time
+        )
+        assert ctx.session_id == "test-session-123"
+        assert ctx.session_start_time == start_time
+
+
+# ============================================================================
+# SlashCommandRegistry Tests
+# ============================================================================
+
+class TestSlashCommandRegistry:
+    """Tests for SlashCommandRegistry."""
+    
+    def test_register_command(self):
+        """Test registering a command."""
+        registry = SlashCommandRegistry()
+        cmd = SlashCommand(name="test", description="Test")
+        
+        registry.register(cmd)
+        
+        assert registry.get("test") is not None
+        assert registry.get("test").name == "test"
+    
+    def test_register_command_with_aliases(self):
+        """Test registering a command with aliases."""
+        registry = SlashCommandRegistry()
+        cmd = SlashCommand(
+            name="help",
+            description="Help",
+            alt_names=["h", "?"]
+        )
+        
+        registry.register(cmd)
+        
+        # Should be accessible by name and aliases
+        assert registry.get("help") is not None
+        assert registry.get("h") is not None
+        assert registry.get("?") is not None
+        
+        # All should return the same command
+        assert registry.get("help") == registry.get("h")
+        assert registry.get("h") == registry.get("?")
+    
+    def test_get_nonexistent_command(self):
+        """Test getting a non-existent command."""
+        registry = SlashCommandRegistry()
+        assert registry.get("nonexistent") is None
+    
+    def test_unregister_command(self):
+        """Test unregistering a command."""
+        registry = SlashCommandRegistry()
+        cmd = SlashCommand(name="test", description="Test", alt_names=["t"])
+        
+        registry.register(cmd)
+        assert registry.get("test") is not None
+        
+        result = registry.unregister("test")
+        assert result is True
+        assert registry.get("test") is None
+        assert registry.get("t") is None  # Alias should also be removed
+    
+    def test_unregister_nonexistent(self):
+        """Test unregistering a non-existent command."""
+        registry = SlashCommandRegistry()
+        result = registry.unregister("nonexistent")
+        assert result is False
+    
+    def test_get_all_commands(self):
+        """Test getting all commands."""
+        registry = SlashCommandRegistry()
+        registry.register(SlashCommand(name="cmd1", description="Cmd 1"))
+        registry.register(SlashCommand(name="cmd2", description="Cmd 2"))
+        registry.register(SlashCommand(name="cmd3", description="Cmd 3"))
+        
+        all_cmds = registry.get_all()
+        assert len(all_cmds) == 3
+        names = [cmd.name for cmd in all_cmds]
+        assert "cmd1" in names
+        assert "cmd2" in names
+        assert "cmd3" in names
+    
+    def test_get_names(self):
+        """Test getting all command names including aliases."""
+        registry = SlashCommandRegistry()
+        registry.register(SlashCommand(name="help", description="Help", alt_names=["h"]))
+        registry.register(SlashCommand(name="exit", description="Exit", alt_names=["q", "quit"]))
+        
+        names = registry.get_names()
+        assert "help" in names
+        assert "h" in names
+        assert "exit" in names
+        assert "q" in names
+        assert "quit" in names
+
+
+# ============================================================================
+# SlashCommandParser Tests
+# ============================================================================
+
+class TestSlashCommandParser:
+    """Tests for SlashCommandParser."""
+    
+    @pytest.fixture
+    def parser(self):
+        """Create a parser with test commands."""
+        registry = SlashCommandRegistry()
+        registry.register(SlashCommand(name="help", description="Help", alt_names=["h"]))
+        registry.register(SlashCommand(name="cost", description="Cost"))
+        registry.register(SlashCommand(
+            name="memory",
+            description="Memory",
+            sub_commands=[
+                SlashCommand(name="add", description="Add memory"),
+                SlashCommand(name="list", description="List memories"),
+            ]
+        ))
+        return SlashCommandParser(registry)
+    
+    def test_is_slash_command(self, parser):
+        """Test slash command detection."""
+        assert parser.is_slash_command("/help") is True
+        assert parser.is_slash_command("/cost") is True
+        assert parser.is_slash_command("help") is False
+        assert parser.is_slash_command("") is False
+    
+    def test_is_not_code_comment(self, parser):
+        """Test that code comments are not detected as commands."""
+        assert parser.is_slash_command("// This is a comment") is False
+        assert parser.is_slash_command("/* Block comment */") is False
+    
+    def test_parse_simple_command(self, parser):
+        """Test parsing a simple command."""
+        result = parser.parse("/help")
+        
+        assert result.command is not None
+        assert result.command.name == "help"
+        assert result.args == ""
+        assert result.canonical_path == ["help"]
+        assert result.error is None
+    
+    def test_parse_command_with_args(self, parser):
+        """Test parsing a command with arguments."""
+        result = parser.parse("/help model")
+        
+        assert result.command is not None
+        assert result.command.name == "help"
+        assert result.args == "model"
+    
+    def test_parse_command_by_alias(self, parser):
+        """Test parsing a command by alias."""
+        result = parser.parse("/h")
+        
+        assert result.command is not None
+        assert result.command.name == "help"
+    
+    def test_parse_subcommand(self, parser):
+        """Test parsing a sub-command."""
+        result = parser.parse("/memory add some data")
+        
+        assert result.command is not None
+        assert result.command.name == "add"
+        assert result.args == "some data"
+        assert result.canonical_path == ["memory", "add"]
+    
+    def test_parse_unknown_command(self, parser):
+        """Test parsing an unknown command."""
+        result = parser.parse("/unknown")
+        
+        assert result.command is None
+        assert result.canonical_path == []
+    
+    def test_parse_empty_command(self, parser):
+        """Test parsing empty command."""
+        result = parser.parse("/")
+        
+        assert result.error == "Empty command"
+    
+    def test_parse_not_slash_command(self, parser):
+        """Test parsing non-slash command."""
+        result = parser.parse("regular text")
+        
+        assert result.error == "Not a slash command"
+
+
+# ============================================================================
+# Built-in Command Tests
+# ============================================================================
+
+class TestBuiltinCommands:
+    """Tests for built-in commands."""
+    
+    @pytest.fixture
+    def context(self):
+        """Create a test context."""
+        ctx = CommandContext(
+            total_tokens=1000,
+            total_cost=0.003,
+            prompt_count=5,
+            session_start_time=time.time() - 120  # 2 minutes ago
+        )
+        ctx.config["command_registry"] = create_default_registry()
+        return ctx
+    
+    def test_cmd_help_general(self, context):
+        """Test general help command."""
+        with patch('rich.console.Console.print'):
+            result = cmd_help(context, "")
+        
+        assert result["type"] == "help"
+    
+    def test_cmd_help_specific(self, context):
+        """Test help for specific command."""
+        with patch('rich.console.Console.print'):
+            result = cmd_help(context, "cost")
+        
+        assert result["type"] == "help"
+        assert result["command"] == "cost"
+    
+    def test_cmd_help_unknown(self, context):
+        """Test help for unknown command."""
+        with patch('rich.console.Console.print'):
+            result = cmd_help(context, "unknown_cmd")
+        
+        assert result["type"] == "error"
+    
+    def test_cmd_cost(self, context):
+        """Test cost command."""
+        with patch('rich.console.Console.print'):
+            result = cmd_cost(context, "")
+        
+        assert result["type"] == "stats"
+        assert result["tokens"] == 1000
+        assert result["cost"] == 0.003
+        assert result["prompts"] == 5
+    
+    def test_cmd_clear(self, context):
+        """Test clear command."""
+        mock_agent = MagicMock()
+        context.agent = mock_agent
+        
+        with patch('rich.console.Console.print'):
+            result = cmd_clear(context, "")
+        
+        assert result["type"] == "clear"
+        mock_agent.clear_history.assert_called_once()
+    
+    def test_cmd_model_show(self, context):
+        """Test model command without args (show current)."""
+        mock_agent = MagicMock()
+        mock_agent.llm = MagicMock(model="gpt-4o")
+        context.agent = mock_agent
+        
+        with patch('rich.console.Console.print'):
+            result = cmd_model(context, "")
+        
+        assert result["type"] == "model_info"
+        assert result["model"] == "gpt-4o"
+    
+    def test_cmd_model_change(self, context):
+        """Test model command with args (change model)."""
+        mock_agent = MagicMock()
+        context.agent = mock_agent
+        
+        with patch('rich.console.Console.print'):
+            result = cmd_model(context, "gpt-4o-mini")
+        
+        assert result["type"] == "model_change"
+        assert result["model"] == "gpt-4o-mini"
+    
+    def test_cmd_tokens(self, context):
+        """Test tokens command."""
+        with patch('rich.console.Console.print'):
+            result = cmd_tokens(context, "")
+        
+        assert result["type"] == "tokens"
+        assert result["total"] == 1000
+    
+    def test_cmd_plan_with_args(self, context):
+        """Test plan command with task."""
+        with patch('rich.console.Console.print'):
+            result = cmd_plan(context, "build a REST API")
+        
+        assert result["type"] == "submit_prompt"
+        assert "build a REST API" in result["content"]
+    
+    def test_cmd_plan_without_args(self, context):
+        """Test plan command without task."""
+        with patch('rich.console.Console.print'):
+            result = cmd_plan(context, "")
+        
+        assert result["type"] == "help"
+    
+    def test_cmd_exit(self, context):
+        """Test exit command."""
+        with patch('rich.console.Console.print'):
+            result = cmd_exit(context, "")
+        
+        assert result["type"] == "exit"
+
+
+# ============================================================================
+# SlashCommandHandler Tests
+# ============================================================================
+
+class TestSlashCommandHandler:
+    """Tests for SlashCommandHandler."""
+    
+    def test_handler_creation(self):
+        """Test handler creation."""
+        handler = SlashCommandHandler()
+        assert handler.registry is not None
+        assert handler.parser is not None
+    
+    def test_is_command(self):
+        """Test command detection."""
+        handler = SlashCommandHandler()
+        
+        assert handler.is_command("/help") is True
+        assert handler.is_command("/cost") is True
+        assert handler.is_command("regular text") is False
+    
+    def test_execute_help(self):
+        """Test executing help command."""
+        handler = SlashCommandHandler()
+        
+        with patch('rich.console.Console.print'):
+            result = handler.execute("/help")
+        
+        assert result is not None
+        assert result["type"] == "help"
+    
+    def test_execute_unknown_command(self):
+        """Test executing unknown command."""
+        handler = SlashCommandHandler()
+        
+        result = handler.execute("/unknown_command_xyz")
+        
+        assert result is not None
+        assert result["type"] == "error"
+    
+    def test_execute_non_command(self):
+        """Test executing non-command text."""
+        handler = SlashCommandHandler()
+        
+        result = handler.execute("regular text")
+        
+        assert result is None
+    
+    def test_register_custom_command(self):
+        """Test registering a custom command."""
+        handler = SlashCommandHandler()
+        
+        def custom_action(ctx, args):
+            return {"type": "custom", "args": args}
+        
+        handler.register_command(SlashCommand(
+            name="custom",
+            description="Custom command",
+            action=custom_action
+        ))
+        
+        result = handler.execute("/custom test args")
+        
+        assert result is not None
+        assert result["type"] == "custom"
+        assert result["args"] == "test args"
+    
+    def test_get_completions(self):
+        """Test command completions."""
+        handler = SlashCommandHandler()
+        
+        completions = handler.get_completions("/he")
+        assert "/help" in completions
+        
+        completions = handler.get_completions("/co")
+        assert "/cost" in completions
+        assert "/commit" in completions
+        
+        completions = handler.get_completions("regular")
+        assert completions == []
+    
+    def test_set_context(self):
+        """Test setting context."""
+        handler = SlashCommandHandler()
+        ctx = CommandContext(total_tokens=500)
+        
+        handler.set_context(ctx)
+        
+        assert handler._context is ctx
+        assert "command_registry" in ctx.config
+
+
+# ============================================================================
+# Default Registry Tests
+# ============================================================================
+
+class TestDefaultRegistry:
+    """Tests for default command registry."""
+    
+    def test_default_registry_has_core_commands(self):
+        """Test that default registry has core commands."""
+        registry = create_default_registry()
+        
+        # Core commands should exist
+        assert registry.get("help") is not None
+        assert registry.get("cost") is not None
+        assert registry.get("clear") is not None
+        assert registry.get("model") is not None
+        assert registry.get("tokens") is not None
+        assert registry.get("plan") is not None
+        assert registry.get("exit") is not None
+    
+    def test_default_registry_aliases(self):
+        """Test that default registry has aliases."""
+        registry = create_default_registry()
+        
+        # Help aliases
+        assert registry.get("h") is not None
+        assert registry.get("?") is not None
+        
+        # Exit aliases
+        assert registry.get("q") is not None
+        assert registry.get("quit") is not None
+        
+        # Cost aliases
+        assert registry.get("usage") is not None
+        assert registry.get("stats") is not None
+
+
+# ============================================================================
+# Integration Tests (require real execution)
+# ============================================================================
+
+class TestSlashCommandsIntegration:
+    """Integration tests for slash commands."""
+    
+    def test_full_command_flow(self):
+        """Test full command execution flow."""
+        handler = SlashCommandHandler(verbose=True)
+        
+        # Set up context
+        ctx = CommandContext(
+            total_tokens=2500,
+            total_cost=0.0075,
+            prompt_count=10,
+            session_start_time=time.time() - 300
+        )
+        handler.set_context(ctx)
+        
+        # Execute commands
+        with patch('rich.console.Console.print'):
+            help_result = handler.execute("/help")
+            cost_result = handler.execute("/cost")
+            tokens_result = handler.execute("/tokens")
+        
+        assert help_result["type"] == "help"
+        assert cost_result["type"] == "stats"
+        assert cost_result["tokens"] == 2500
+        assert tokens_result["type"] == "tokens"
+    
+    def test_command_with_special_characters(self):
+        """Test commands with special characters in args."""
+        handler = SlashCommandHandler()
+        
+        with patch('rich.console.Console.print'):
+            result = handler.execute("/plan Build a REST API with /users endpoint")
+        
+        assert result is not None
+        assert result["type"] == "submit_prompt"
+        assert "/users" in result["content"]

src/praisonai/tests/unit/integrations/test_claude_code.py

@@ -163,11 +163,16 @@ class TestClaudeCodeSDKIntegration:
         assert isinstance(integration.sdk_available, bool)
     
     def test_use_sdk_option(self):
-        """Test use_sdk option."""
-        from praisonai.integrations.claude_code import ClaudeCodeIntegration
+        """Test use_sdk option.
+        
+        Note: use_sdk is only True if both use_sdk=True AND SDK is available.
+        Since SDK is not installed in test environment, use_sdk will be False.
+        """
+        from praisonai.integrations.claude_code import ClaudeCodeIntegration, CLAUDE_SDK_AVAILABLE
         
         integration = ClaudeCodeIntegration(use_sdk=True)
-        assert integration.use_sdk is True
+        # use_sdk is True only if SDK is available
+        assert integration.use_sdk == (True and CLAUDE_SDK_AVAILABLE)
         
         integration2 = ClaudeCodeIntegration(use_sdk=False)
         assert integration2.use_sdk is False

src/praisonai/tests/unit/scheduler/__init__.py

@@ -0,0 +1 @@
+"""Unit tests for scheduler module."""

src/praisonai/tests/unit/scheduler/test_agent_scheduler.py

@@ -0,0 +1,482 @@
+"""
+Unit tests for AgentScheduler.
+
+Tests for:
+- AgentScheduler initialization
+- Start/stop functionality
+- Execution logic
+- Callbacks
+- Threading
+- Statistics
+"""
+
+import pytest
+import time
+import threading
+from unittest.mock import Mock, patch, call
+from praisonai.scheduler.agent_scheduler import AgentScheduler, create_agent_scheduler
+
+
+class TestAgentSchedulerInit:
+    """Test AgentScheduler initialization."""
+    
+    def test_init_with_agent_and_task(self):
+        """Test initialization with agent and task."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        assert scheduler.agent == mock_agent
+        assert scheduler.task == "Test task"
+        assert scheduler.is_running == False
+        assert scheduler._execution_count == 0
+        assert scheduler._success_count == 0
+        assert scheduler._failure_count == 0
+    
+    def test_init_with_config(self):
+        """Test initialization with optional config."""
+        mock_agent = Mock()
+        config = {"key": "value"}
+        scheduler = AgentScheduler(mock_agent, "Test task", config=config)
+        
+        assert scheduler.config == config
+    
+    def test_init_with_callbacks(self):
+        """Test initialization with callbacks."""
+        mock_agent = Mock()
+        on_success = Mock()
+        on_failure = Mock()
+        
+        scheduler = AgentScheduler(
+            mock_agent, 
+            "Test task",
+            on_success=on_success,
+            on_failure=on_failure
+        )
+        
+        assert scheduler.on_success == on_success
+        assert scheduler.on_failure == on_failure
+    
+    def test_init_default_values(self):
+        """Test initialization sets correct default values."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        assert scheduler.config == {}
+        assert scheduler.on_success is None
+        assert scheduler.on_failure is None
+        assert scheduler._stop_event is not None
+        assert scheduler._thread is None
+        assert scheduler._executor is not None
+
+
+class TestAgentSchedulerStartStop:
+    """Test AgentScheduler start and stop methods."""
+    
+    def test_start_with_valid_schedule(self):
+        """Test start() with valid schedule expression."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        result = scheduler.start("hourly", run_immediately=False)
+        
+        assert result == True
+        assert scheduler.is_running == True
+        assert scheduler._thread is not None
+        assert scheduler._thread.daemon == True
+        
+        scheduler.stop()
+    
+    def test_start_already_running(self):
+        """Test start() when already running returns False."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        scheduler.start("hourly", run_immediately=False)
+        result = scheduler.start("hourly", run_immediately=False)
+        
+        assert result == False
+        
+        scheduler.stop()
+    
+    def test_start_with_invalid_schedule(self):
+        """Test start() with invalid schedule returns False."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        result = scheduler.start("invalid_format")
+        
+        assert result == False
+        assert scheduler.is_running == False
+    
+    def test_stop_when_running(self):
+        """Test stop() when scheduler is running."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="result")
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        scheduler.start("*/1s", run_immediately=False)
+        time.sleep(0.1)
+        result = scheduler.stop()
+        
+        assert result == True
+        assert scheduler.is_running == False
+    
+    def test_stop_when_not_running(self):
+        """Test stop() when scheduler is not running."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        result = scheduler.stop()
+        
+        assert result == True
+        assert scheduler.is_running == False
+    
+    def test_is_running_flag(self):
+        """Test is_running flag changes correctly."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        assert scheduler.is_running == False
+        
+        scheduler.start("hourly", run_immediately=False)
+        assert scheduler.is_running == True
+        
+        scheduler.stop()
+        assert scheduler.is_running == False
+
+
+class TestAgentSchedulerExecution:
+    """Test AgentScheduler execution methods."""
+    
+    def test_execute_once_success(self):
+        """Test execute_once() with successful execution."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="Agent result")
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        result = scheduler.execute_once()
+        
+        assert result == "Agent result"
+        mock_agent.start.assert_called_once_with("Test task")
+    
+    def test_execute_once_failure(self):
+        """Test execute_once() with failed execution."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(side_effect=Exception("Agent error"))
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        with pytest.raises(Exception, match="Agent error"):
+            scheduler.execute_once()
+    
+    @patch('time.sleep')
+    def test_execute_with_retry_success_first_try(self, mock_sleep):
+        """Test _execute_with_retry() succeeds on first try."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="Success")
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        scheduler._execute_with_retry(max_retries=3)
+        
+        assert scheduler._success_count == 1
+        assert scheduler._failure_count == 0
+        mock_sleep.assert_not_called()
+    
+    @patch('time.sleep')
+    def test_execute_with_retry_success_on_retry(self, mock_sleep):
+        """Test _execute_with_retry() succeeds on retry."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(side_effect=[
+            Exception("Fail 1"),
+            "Success"
+        ])
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        scheduler._execute_with_retry(max_retries=3)
+        
+        assert scheduler._success_count == 1
+        assert scheduler._failure_count == 0
+        assert mock_agent.start.call_count == 2
+    
+    @patch('time.sleep')
+    def test_execute_with_retry_all_fail(self, mock_sleep):
+        """Test _execute_with_retry() when all retries fail."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(side_effect=Exception("Always fails"))
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        scheduler._execute_with_retry(max_retries=3)
+        
+        assert scheduler._success_count == 0
+        assert scheduler._failure_count == 1
+        assert mock_agent.start.call_count == 3
+    
+    @patch('time.sleep')
+    def test_execute_with_retry_exponential_backoff(self, mock_sleep):
+        """Test _execute_with_retry() uses exponential backoff."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(side_effect=Exception("Always fails"))
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        scheduler._execute_with_retry(max_retries=3)
+        
+        # Should sleep 30s, then 60s (exponential backoff)
+        assert mock_sleep.call_count == 2
+        mock_sleep.assert_has_calls([call(30), call(60)])
+
+
+class TestAgentSchedulerCallbacks:
+    """Test AgentScheduler callback functionality."""
+    
+    def test_on_success_callback_invoked(self):
+        """Test on_success callback is invoked on success."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="Success result")
+        on_success = Mock()
+        
+        scheduler = AgentScheduler(mock_agent, "Test task", on_success=on_success)
+        scheduler.execute_once()
+        
+        on_success.assert_called_once_with("Success result")
+    
+    @patch('time.sleep')
+    def test_on_failure_callback_invoked(self, mock_sleep):
+        """Test on_failure callback is invoked on failure."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(side_effect=Exception("Error"))
+        on_failure = Mock()
+        
+        scheduler = AgentScheduler(mock_agent, "Test task", on_failure=on_failure)
+        scheduler._execute_with_retry(max_retries=2)
+        
+        on_failure.assert_called_once()
+    
+    def test_callback_with_none(self):
+        """Test execution works when callbacks are None."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="Success")
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        result = scheduler.execute_once()
+        
+        assert result == "Success"
+    
+    def test_callback_exception_handling(self):
+        """Test callback exceptions don't break execution."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="Success")
+        on_success = Mock(side_effect=Exception("Callback error"))
+        
+        scheduler = AgentScheduler(mock_agent, "Test task", on_success=on_success)
+        
+        # Should not raise exception even though callback fails
+        result = scheduler.execute_once()
+        assert result == "Success"
+
+
+class TestAgentSchedulerThreading:
+    """Test AgentScheduler threading functionality."""
+    
+    def test_thread_creation_on_start(self):
+        """Test thread is created when start() is called."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        scheduler.start("hourly", run_immediately=False)
+        
+        assert scheduler._thread is not None
+        assert isinstance(scheduler._thread, threading.Thread)
+        assert scheduler._thread.is_alive()
+        
+        scheduler.stop()
+    
+    def test_daemon_thread_flag(self):
+        """Test thread is created as daemon."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        scheduler.start("hourly", run_immediately=False)
+        
+        assert scheduler._thread.daemon == True
+        
+        scheduler.stop()
+    
+    def test_thread_cleanup_on_stop(self):
+        """Test thread is cleaned up on stop()."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="result")
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        scheduler.start("*/1s", run_immediately=False)
+        time.sleep(0.1)
+        scheduler.stop()
+        
+        time.sleep(0.2)
+        assert scheduler._thread.is_alive() == False
+    
+    def test_graceful_shutdown_timeout(self):
+        """Test graceful shutdown with timeout."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="result")
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        scheduler.start("hourly", run_immediately=False)
+        
+        start_time = time.time()
+        scheduler.stop()
+        duration = time.time() - start_time
+        
+        # Should complete quickly (within timeout)
+        assert duration < 11  # 10 second timeout + 1 second buffer
+
+
+class TestAgentSchedulerIntervals:
+    """Test AgentScheduler interval scheduling."""
+    
+    @patch('time.sleep')
+    def test_run_immediately_true(self, mock_sleep):
+        """Test run_immediately=True executes before schedule."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="result")
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        scheduler.start("hourly", run_immediately=True)
+        
+        time.sleep(0.1)
+        scheduler.stop()
+        
+        # Should have executed at least once immediately
+        assert scheduler._execution_count >= 1
+    
+    def test_run_immediately_false(self):
+        """Test run_immediately=False waits for interval."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="result")
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        initial_count = scheduler._execution_count
+        scheduler.start("hourly", run_immediately=False)
+        
+        time.sleep(0.05)  # Very short wait
+        scheduler.stop()
+        
+        # Should not have executed yet (hourly interval) or at most started one execution
+        assert scheduler._execution_count <= initial_count + 1
+    
+    def test_stop_event_interrupts_wait(self):
+        """Test stop_event interrupts interval wait."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        scheduler.start("hourly", run_immediately=False)
+        
+        start_time = time.time()
+        scheduler.stop()
+        duration = time.time() - start_time
+        
+        # Should stop quickly, not wait full hour
+        assert duration < 2
+
+
+class TestAgentSchedulerStatistics:
+    """Test AgentScheduler statistics tracking."""
+    
+    def test_get_stats_initial_state(self):
+        """Test get_stats() returns correct initial state."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        stats = scheduler.get_stats()
+        
+        assert stats['is_running'] == False
+        assert stats['total_executions'] == 0
+        assert stats['successful_executions'] == 0
+        assert stats['failed_executions'] == 0
+        assert stats['success_rate'] == 0
+    
+    @patch('time.sleep')
+    def test_execution_count_increment(self, mock_sleep):
+        """Test execution count increments."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="result")
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        scheduler._execute_with_retry(max_retries=1)
+        scheduler._execute_with_retry(max_retries=1)
+        
+        stats = scheduler.get_stats()
+        assert stats['total_executions'] == 2
+    
+    @patch('time.sleep')
+    def test_success_count_increment(self, mock_sleep):
+        """Test success count increments."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="result")
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        scheduler._execute_with_retry(max_retries=1)
+        
+        stats = scheduler.get_stats()
+        assert stats['successful_executions'] == 1
+    
+    @patch('time.sleep')
+    def test_failure_count_increment(self, mock_sleep):
+        """Test failure count increments."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(side_effect=Exception("Error"))
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        scheduler._execute_with_retry(max_retries=1)
+        
+        stats = scheduler.get_stats()
+        assert stats['failed_executions'] == 1
+    
+    @patch('time.sleep')
+    def test_success_rate_calculation(self, mock_sleep):
+        """Test success rate is calculated correctly."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(side_effect=[
+            "success",
+            Exception("fail"),
+            "success"
+        ])
+        
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        scheduler._execute_with_retry(max_retries=1)
+        scheduler._execute_with_retry(max_retries=1)
+        scheduler._execute_with_retry(max_retries=1)
+        
+        stats = scheduler.get_stats()
+        assert stats['total_executions'] == 3
+        assert stats['successful_executions'] == 2
+        assert stats['failed_executions'] == 1
+        assert stats['success_rate'] == pytest.approx(66.67, rel=0.1)
+    
+    def test_success_rate_with_zero_executions(self):
+        """Test success rate with zero executions."""
+        mock_agent = Mock()
+        scheduler = AgentScheduler(mock_agent, "Test task")
+        
+        stats = scheduler.get_stats()
+        assert stats['success_rate'] == 0
+
+
+class TestCreateAgentScheduler:
+    """Test create_agent_scheduler factory function."""
+    
+    def test_factory_creates_scheduler(self):
+        """Test factory function creates AgentScheduler."""
+        mock_agent = Mock()
+        scheduler = create_agent_scheduler(mock_agent, "Test task")
+        
+        assert isinstance(scheduler, AgentScheduler)
+        assert scheduler.agent == mock_agent
+        assert scheduler.task == "Test task"
+    
+    def test_factory_with_config(self):
+        """Test factory function with config."""
+        mock_agent = Mock()
+        config = {"key": "value"}
+        scheduler = create_agent_scheduler(mock_agent, "Test task", config=config)
+        
+        assert scheduler.config == config

src/praisonai/tests/unit/scheduler/test_base.py

@@ -0,0 +1,143 @@
+"""
+Unit tests for scheduler base components.
+
+Tests for:
+- ScheduleParser
+- ExecutorInterface
+- PraisonAgentExecutor
+"""
+
+import pytest
+from unittest.mock import Mock
+from praisonai.scheduler.base import ScheduleParser, ExecutorInterface, PraisonAgentExecutor
+
+
+class TestScheduleParser:
+    """Test ScheduleParser schedule expression parsing."""
+    
+    def test_parse_hourly(self):
+        """Test parsing 'hourly' returns 3600 seconds."""
+        result = ScheduleParser.parse("hourly")
+        assert result == 3600
+    
+    def test_parse_daily(self):
+        """Test parsing 'daily' returns 86400 seconds."""
+        result = ScheduleParser.parse("daily")
+        assert result == 86400
+    
+    def test_parse_minutes_format(self):
+        """Test parsing '*/30m' returns 1800 seconds."""
+        result = ScheduleParser.parse("*/30m")
+        assert result == 1800
+    
+    def test_parse_hours_format(self):
+        """Test parsing '*/6h' returns 21600 seconds."""
+        result = ScheduleParser.parse("*/6h")
+        assert result == 21600
+    
+    def test_parse_plain_number(self):
+        """Test parsing '3600' returns 3600 seconds."""
+        result = ScheduleParser.parse("3600")
+        assert result == 3600
+    
+    def test_parse_invalid_format(self):
+        """Test parsing invalid format raises ValueError."""
+        with pytest.raises(ValueError, match="Unsupported schedule format"):
+            ScheduleParser.parse("invalid_format")
+    
+    def test_parse_case_insensitive(self):
+        """Test parsing is case insensitive."""
+        assert ScheduleParser.parse("HOURLY") == 3600
+        assert ScheduleParser.parse("Daily") == 86400
+    
+    def test_parse_with_whitespace(self):
+        """Test parsing handles whitespace."""
+        assert ScheduleParser.parse("  hourly  ") == 3600
+    
+    def test_parse_seconds_format(self):
+        """Test parsing '*/30s' returns 30 seconds."""
+        result = ScheduleParser.parse("*/30s")
+        assert result == 30
+    
+    def test_parse_various_minutes(self):
+        """Test parsing various minute formats."""
+        assert ScheduleParser.parse("*/1m") == 60
+        assert ScheduleParser.parse("*/15m") == 900
+        assert ScheduleParser.parse("*/45m") == 2700
+    
+    def test_parse_various_hours(self):
+        """Test parsing various hour formats."""
+        assert ScheduleParser.parse("*/1h") == 3600
+        assert ScheduleParser.parse("*/2h") == 7200
+        assert ScheduleParser.parse("*/12h") == 43200
+
+
+class TestExecutorInterface:
+    """Test ExecutorInterface abstract class."""
+    
+    def test_cannot_instantiate_interface(self):
+        """Test ExecutorInterface cannot be instantiated directly."""
+        with pytest.raises(TypeError):
+            ExecutorInterface()
+    
+    def test_must_implement_execute(self):
+        """Test subclass must implement execute method."""
+        class IncompleteExecutor(ExecutorInterface):
+            pass
+        
+        with pytest.raises(TypeError):
+            IncompleteExecutor()
+    
+    def test_valid_implementation(self):
+        """Test valid implementation of ExecutorInterface."""
+        class ValidExecutor(ExecutorInterface):
+            def execute(self, task: str):
+                return "result"
+        
+        executor = ValidExecutor()
+        assert executor.execute("test") == "result"
+
+
+class TestPraisonAgentExecutor:
+    """Test PraisonAgentExecutor implementation."""
+    
+    def test_init_with_agent(self):
+        """Test initialization with agent."""
+        mock_agent = Mock()
+        executor = PraisonAgentExecutor(mock_agent)
+        assert executor.agent == mock_agent
+    
+    def test_execute_success(self):
+        """Test successful execution."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(return_value="Agent result")
+        
+        executor = PraisonAgentExecutor(mock_agent)
+        result = executor.execute("Test task")
+        
+        assert result == "Agent result"
+        mock_agent.start.assert_called_once_with("Test task")
+    
+    def test_execute_failure(self):
+        """Test execution failure raises exception."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(side_effect=Exception("Agent error"))
+        
+        executor = PraisonAgentExecutor(mock_agent)
+        
+        with pytest.raises(Exception, match="Agent error"):
+            executor.execute("Test task")
+    
+    def test_execute_with_different_tasks(self):
+        """Test execution with different tasks."""
+        mock_agent = Mock()
+        mock_agent.start = Mock(side_effect=lambda task: f"Result for: {task}")
+        
+        executor = PraisonAgentExecutor(mock_agent)
+        
+        result1 = executor.execute("Task 1")
+        result2 = executor.execute("Task 2")
+        
+        assert result1 == "Result for: Task 1"
+        assert result2 == "Result for: Task 2"
+        assert mock_agent.start.call_count == 2

src/praisonai/tests/unit/test_model_routing.py

@@ -0,0 +1,580 @@
+"""
+Unit tests for Model Routing features.
+
+Tests cover:
+1. Model config parsing from agents.yaml/workflow.yaml
+2. Per-agent LLM field support
+3. Unified CLI Router with ModelRouter
+4. Custom model profiles
+
+TDD approach - tests written before implementation.
+"""
+
+import pytest
+import yaml
+import os
+import sys
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+
+# =============================================================================
+# Feature 1: Model Config in YAML
+# =============================================================================
+
+class TestModelConfigParsing:
+    """Tests for parsing 'models' section from agents.yaml/workflow.yaml."""
+    
+    def test_parse_models_section_basic(self):
+        """Test parsing basic models configuration from YAML."""
+        yaml_content = """
+name: Test Workflow
+description: Test workflow with custom models
+
+models:
+  gpt-4o-mini:
+    provider: openai
+    complexity: [simple, moderate]
+    cost_per_1k: 0.00075
+    capabilities: [text, function-calling]
+
+agents:
+  researcher:
+    name: Researcher
+    role: Research Analyst
+    goal: Research topics
+
+steps:
+  - agent: researcher
+    action: "Research: {{input}}"
+"""
+        config = yaml.safe_load(yaml_content)
+        
+        # Verify models section exists
+        assert 'models' in config
+        assert 'gpt-4o-mini' in config['models']
+        
+        model_config = config['models']['gpt-4o-mini']
+        assert model_config['provider'] == 'openai'
+        assert model_config['complexity'] == ['simple', 'moderate']
+        assert model_config['cost_per_1k'] == 0.00075
+        assert 'text' in model_config['capabilities']
+    
+    def test_parse_multiple_models(self):
+        """Test parsing multiple model configurations."""
+        yaml_content = """
+models:
+  gpt-4o-mini:
+    provider: openai
+    complexity: [simple, moderate]
+    cost_per_1k: 0.00075
+    capabilities: [text, function-calling]
+  
+  claude-3-5-sonnet:
+    provider: anthropic
+    complexity: [moderate, complex, very_complex]
+    cost_per_1k: 0.009
+    capabilities: [text, vision, function-calling]
+  
+  custom-openrouter-model:
+    provider: openrouter
+    complexity: [moderate, complex]
+    cost_per_1k: 0.001
+    capabilities: [text]
+    context_window: 32000
+
+agents:
+  researcher:
+    name: Researcher
+    role: Research Analyst
+    goal: Research topics
+"""
+        config = yaml.safe_load(yaml_content)
+        
+        assert len(config['models']) == 3
+        assert 'gpt-4o-mini' in config['models']
+        assert 'claude-3-5-sonnet' in config['models']
+        assert 'custom-openrouter-model' in config['models']
+        
+        # Verify custom model has context_window
+        custom_model = config['models']['custom-openrouter-model']
+        assert custom_model.get('context_window') == 32000
+    
+    def test_parse_model_with_all_fields(self):
+        """Test parsing model with all optional fields."""
+        yaml_content = """
+models:
+  full-model:
+    provider: openai
+    complexity: [simple, moderate, complex]
+    cost_per_1k: 0.005
+    capabilities: [text, vision, function-calling, streaming]
+    context_window: 128000
+    supports_tools: true
+    supports_streaming: true
+    strengths: [reasoning, code-generation, analysis]
+"""
+        config = yaml.safe_load(yaml_content)
+        
+        model = config['models']['full-model']
+        assert model['provider'] == 'openai'
+        assert model['context_window'] == 128000
+        assert model['supports_tools'] is True
+        assert model['supports_streaming'] is True
+        assert 'reasoning' in model['strengths']
+    
+    def test_models_section_optional(self):
+        """Test that models section is optional - backward compatibility."""
+        yaml_content = """
+name: Simple Workflow
+
+agents:
+  researcher:
+    name: Researcher
+    role: Research Analyst
+    goal: Research topics
+
+steps:
+  - agent: researcher
+    action: "Research: {{input}}"
+"""
+        config = yaml.safe_load(yaml_content)
+        
+        # models section should not exist
+        assert 'models' not in config or config.get('models') is None
+        # But agents should still work
+        assert 'agents' in config
+
+
+class TestModelConfigToModelProfile:
+    """Tests for converting YAML model config to ModelProfile objects."""
+    
+    def test_convert_yaml_to_model_profile(self):
+        """Test converting YAML model config to ModelProfile."""
+        from praisonai.cli.features.router import RouterHandler
+        
+        yaml_model_config = {
+            'provider': 'openai',
+            'complexity': ['simple', 'moderate'],
+            'cost_per_1k': 0.00075,
+            'capabilities': ['text', 'function-calling'],
+            'context_window': 128000,
+            'supports_tools': True,
+            'strengths': ['speed', 'cost-effective']
+        }
+        
+        handler = RouterHandler()
+        profile = handler.yaml_to_model_profile('gpt-4o-mini', yaml_model_config)
+        
+        assert profile is not None
+        assert profile.name == 'gpt-4o-mini'
+        assert profile.provider == 'openai'
+        assert profile.cost_per_1k_tokens == 0.00075
+        assert profile.context_window == 128000
+    
+    def test_convert_complexity_strings_to_enum(self):
+        """Test converting complexity strings to TaskComplexity enum."""
+        from praisonai.cli.features.router import RouterHandler
+        
+        yaml_model_config = {
+            'provider': 'anthropic',
+            'complexity': ['moderate', 'complex', 'very_complex'],
+            'cost_per_1k': 0.009,
+            'capabilities': ['text']
+        }
+        
+        handler = RouterHandler()
+        profile = handler.yaml_to_model_profile('claude-3-5-sonnet', yaml_model_config)
+        
+        # Complexity range should be (MODERATE, VERY_COMPLEX)
+        min_complexity, max_complexity = profile.complexity_range
+        assert min_complexity.value == 2  # MODERATE
+        assert max_complexity.value == 4  # VERY_COMPLEX
+
+
+class TestRouterWithCustomModels:
+    """Tests for RouterHandler using custom models from YAML."""
+    
+    def test_router_loads_custom_models(self):
+        """Test that router loads custom models from YAML config."""
+        from praisonai.cli.features.router import RouterHandler
+        
+        models_config = {
+            'my-custom-model': {
+                'provider': 'openrouter',
+                'complexity': ['simple', 'moderate'],
+                'cost_per_1k': 0.001,
+                'capabilities': ['text', 'function-calling']
+            }
+        }
+        
+        handler = RouterHandler()
+        handler.load_models_from_config(models_config)
+        
+        # Custom model should be available
+        assert 'my-custom-model' in handler.get_available_models()
+    
+    def test_router_selects_custom_model(self):
+        """Test that router can select custom model based on complexity."""
+        from praisonai.cli.features.router import RouterHandler
+        
+        models_config = {
+            'cheap-model': {
+                'provider': 'custom',
+                'complexity': ['simple'],
+                'cost_per_1k': 0.0001,
+                'capabilities': ['text']
+            },
+            'expensive-model': {
+                'provider': 'custom',
+                'complexity': ['complex', 'very_complex'],
+                'cost_per_1k': 0.05,
+                'capabilities': ['text', 'function-calling']
+            }
+        }
+        
+        handler = RouterHandler()
+        handler.load_models_from_config(models_config)
+        
+        # Simple task should select cheap model
+        simple_model = handler.select_model("What is 2+2?")
+        assert simple_model == 'cheap-model'
+        
+        # Complex task should select expensive model
+        complex_model = handler.select_model(
+            "Analyze the comprehensive impact of quantum computing on cybersecurity"
+        )
+        assert complex_model == 'expensive-model'
+    
+    def test_router_merges_with_default_models(self):
+        """Test that custom models merge with default models."""
+        from praisonai.cli.features.router import RouterHandler
+        
+        models_config = {
+            'my-custom-model': {
+                'provider': 'openrouter',
+                'complexity': ['moderate'],
+                'cost_per_1k': 0.002,
+                'capabilities': ['text']
+            }
+        }
+        
+        handler = RouterHandler()
+        handler.load_models_from_config(models_config, merge_with_defaults=True)
+        
+        available = handler.get_available_models()
+        
+        # Should have both custom and default models
+        assert 'my-custom-model' in available
+        assert 'gpt-4o-mini' in available  # Default model
+
+
+# =============================================================================
+# Feature 2: Per-Agent LLM Field
+# =============================================================================
+
+class TestPerAgentLLM:
+    """Tests for per-agent LLM configuration in YAML."""
+    
+    def test_parse_agent_with_llm_field(self):
+        """Test parsing agent with explicit llm field."""
+        yaml_content = """
+agents:
+  researcher:
+    name: Researcher
+    role: Research Analyst
+    goal: Research topics
+    llm: gpt-4o
+    
+  writer:
+    name: Writer
+    role: Content Writer
+    goal: Write content
+    llm: claude-3-5-sonnet-20241022
+"""
+        config = yaml.safe_load(yaml_content)
+        
+        assert config['agents']['researcher']['llm'] == 'gpt-4o'
+        assert config['agents']['writer']['llm'] == 'claude-3-5-sonnet-20241022'
+    
+    def test_parse_agent_with_llm_routing(self):
+        """Test parsing agent with llm_routing strategy."""
+        yaml_content = """
+agents:
+  smart_agent:
+    name: Smart Agent
+    role: Adaptive Assistant
+    goal: Handle various tasks
+    llm_routing: auto
+    llm_models:
+      - gpt-4o-mini
+      - gpt-4o
+      - claude-3-5-sonnet-20241022
+"""
+        config = yaml.safe_load(yaml_content)
+        
+        agent = config['agents']['smart_agent']
+        assert agent['llm_routing'] == 'auto'
+        assert len(agent['llm_models']) == 3
+    
+    def test_agent_llm_defaults_when_not_specified(self):
+        """Test that agent uses default LLM when not specified."""
+        yaml_content = """
+agents:
+  researcher:
+    name: Researcher
+    role: Research Analyst
+    goal: Research topics
+    # No llm field - should use default
+"""
+        config = yaml.safe_load(yaml_content)
+        
+        # llm field should not exist
+        assert 'llm' not in config['agents']['researcher']
+    
+    def test_agent_llm_with_provider_prefix(self):
+        """Test parsing agent LLM with provider/model format."""
+        yaml_content = """
+agents:
+  researcher:
+    name: Researcher
+    role: Research Analyst
+    goal: Research topics
+    llm: openrouter/anthropic/claude-3-5-sonnet
+"""
+        config = yaml.safe_load(yaml_content)
+        
+        assert config['agents']['researcher']['llm'] == 'openrouter/anthropic/claude-3-5-sonnet'
+
+
+class TestAgentCreationWithLLM:
+    """Tests for creating Agent objects with LLM from YAML config."""
+    
+    def test_create_agent_with_custom_llm(self):
+        """Test that Agent config with custom LLM is properly parsed."""
+        agent_config = {
+            'name': 'Researcher',
+            'role': 'Research Analyst',
+            'goal': 'Research topics',
+            'llm': 'gpt-4o'
+        }
+        
+        # This tests the parsing logic, not actual agent creation
+        llm_value = agent_config.get('llm', 'gpt-4o-mini')
+        assert llm_value == 'gpt-4o'
+    
+    def test_agent_config_with_routing_strategy(self):
+        """Test agent config with routing strategy is properly structured."""
+        agent_config = {
+            'name': 'Smart Agent',
+            'role': 'Adaptive Assistant',
+            'goal': 'Handle various tasks',
+            'llm_routing': 'cost-optimized',
+            'llm_models': ['gpt-4o-mini', 'gpt-4o', 'claude-3-5-sonnet-20241022']
+        }
+        
+        # Verify structure
+        assert agent_config['llm_routing'] == 'cost-optimized'
+        assert isinstance(agent_config['llm_models'], list)
+        assert len(agent_config['llm_models']) == 3
+
+
+# =============================================================================
+# Feature 3: Unified CLI Router with ModelRouter
+# =============================================================================
+
+class TestUnifiedRouter:
+    """Tests for unified RouterHandler that uses ModelRouter internally."""
+    
+    def test_router_handler_uses_model_router(self):
+        """Test that RouterHandler uses ModelRouter for selection."""
+        from praisonai.cli.features.router import RouterHandler
+        
+        handler = RouterHandler()
+        
+        # Should have internal model_router
+        assert hasattr(handler, 'model_router') or hasattr(handler, '_model_router')
+    
+    def test_router_complexity_analysis_matches(self):
+        """Test that complexity analysis is consistent."""
+        from praisonai.cli.features.router import RouterHandler
+        
+        handler = RouterHandler()
+        
+        # Simple prompts
+        assert handler.analyze_complexity("What is 2+2?") == 'simple'
+        assert handler.analyze_complexity("Define photosynthesis") == 'simple'
+        
+        # Complex prompts
+        assert handler.analyze_complexity(
+            "Analyze and research the comprehensive impact of AI on healthcare"
+        ) == 'complex'
+    
+    def test_router_cost_threshold(self):
+        """Test router respects cost threshold."""
+        from praisonai.cli.features.router import RouterHandler
+        
+        handler = RouterHandler()
+        handler.set_cost_threshold(0.001)  # Max $0.001 per 1k tokens
+        
+        # Should only select cheap models
+        model = handler.select_model("Complex analysis task")
+        
+        # Model should be within cost threshold
+        model_cost = handler.get_model_cost(model)
+        assert model_cost <= 0.001
+    
+    def test_router_provider_preference(self):
+        """Test router respects provider preference."""
+        from praisonai.cli.features.router import RouterHandler
+        
+        handler = RouterHandler()
+        
+        # Prefer Anthropic
+        model = handler.select_model(
+            "Write a detailed analysis",
+            preferred_provider='anthropic'
+        )
+        
+        assert 'claude' in model.lower()
+
+
+class TestRouterIntegrationWithWorkflow:
+    """Tests for router integration with workflow execution."""
+    
+    def test_workflow_uses_models_config(self):
+        """Test that workflow uses models config for routing."""
+        yaml_content = """
+name: Routing Workflow
+
+models:
+  fast-model:
+    provider: openai
+    complexity: [simple]
+    cost_per_1k: 0.0001
+    capabilities: [text]
+  
+  smart-model:
+    provider: anthropic
+    complexity: [complex, very_complex]
+    cost_per_1k: 0.01
+    capabilities: [text, function-calling]
+
+workflow:
+  verbose: true
+  router: true  # Enable model routing
+
+agents:
+  researcher:
+    name: Researcher
+    role: Research Analyst
+    goal: Research topics
+    llm_routing: auto  # Use auto-routing with models config
+"""
+        config = yaml.safe_load(yaml_content)
+        
+        # Verify workflow has router enabled
+        assert config['workflow'].get('router') is True
+        
+        # Verify agent has routing enabled
+        assert config['agents']['researcher']['llm_routing'] == 'auto'
+        
+        # Verify models are defined
+        assert 'fast-model' in config['models']
+        assert 'smart-model' in config['models']
+
+
+# =============================================================================
+# Integration Tests
+# =============================================================================
+
+class TestEndToEndModelRouting:
+    """End-to-end tests for model routing feature."""
+    
+    def test_full_yaml_with_model_routing(self):
+        """Test complete YAML with all model routing features."""
+        yaml_content = """
+name: Full Model Routing Workflow
+description: Demonstrates all model routing features
+
+# Custom models configuration
+models:
+  cheap-fast:
+    provider: openai
+    complexity: [simple]
+    cost_per_1k: 0.0001
+    capabilities: [text]
+    context_window: 16000
+  
+  balanced:
+    provider: openai
+    complexity: [moderate]
+    cost_per_1k: 0.001
+    capabilities: [text, function-calling]
+    context_window: 128000
+  
+  premium:
+    provider: anthropic
+    complexity: [complex, very_complex]
+    cost_per_1k: 0.015
+    capabilities: [text, vision, function-calling]
+    context_window: 200000
+    strengths: [reasoning, analysis, code-generation]
+
+workflow:
+  verbose: true
+  router: true
+  routing_strategy: cost-optimized
+
+agents:
+  classifier:
+    name: Classifier
+    role: Request Classifier
+    goal: Classify incoming requests
+    llm: cheap-fast  # Always use cheap model for classification
+  
+  researcher:
+    name: Researcher
+    role: Research Analyst
+    goal: Research topics thoroughly
+    llm_routing: auto  # Auto-select based on task
+    llm_models: [balanced, premium]
+  
+  writer:
+    name: Writer
+    role: Content Writer
+    goal: Write high-quality content
+    llm: premium  # Always use premium for writing
+
+steps:
+  - agent: classifier
+    action: "Classify: {{input}}"
+    
+  - name: routing
+    route:
+      simple: [researcher]
+      complex: [researcher, writer]
+      default: [researcher]
+"""
+        config = yaml.safe_load(yaml_content)
+        
+        # Verify complete structure
+        assert 'models' in config
+        assert len(config['models']) == 3
+        
+        assert 'workflow' in config
+        assert config['workflow']['router'] is True
+        assert config['workflow']['routing_strategy'] == 'cost-optimized'
+        
+        assert 'agents' in config
+        assert config['agents']['classifier']['llm'] == 'cheap-fast'
+        assert config['agents']['researcher']['llm_routing'] == 'auto'
+        assert config['agents']['writer']['llm'] == 'premium'
+        
+        assert 'steps' in config
+        assert len(config['steps']) == 2
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])

src/praisonai/tests/unit/test_profiler.py

@@ -0,0 +1,259 @@
+"""
+Unit tests for PraisonAI Profiler module.
+"""
+
+import time
+
+
+class TestProfiler:
+    """Test Profiler class."""
+    
+    def test_profiler_singleton(self):
+        """Should return same instance."""
+        from praisonai.profiler import Profiler
+        
+        p1 = Profiler()
+        p2 = Profiler()
+        assert p1 is p2
+    
+    def test_enable_disable(self):
+        """Should enable and disable profiling."""
+        from praisonai.profiler import Profiler
+        
+        Profiler.disable()
+        assert not Profiler.is_enabled()
+        
+        Profiler.enable()
+        assert Profiler.is_enabled()
+        
+        Profiler.disable()
+    
+    def test_record_timing(self):
+        """Should record timing."""
+        from praisonai.profiler import Profiler
+        
+        Profiler.enable()
+        Profiler.clear()
+        
+        Profiler.record_timing("test_op", 100.5, "test")
+        
+        timings = Profiler.get_timings()
+        assert len(timings) >= 1
+        assert timings[-1].name == "test_op"
+        assert timings[-1].duration_ms == 100.5
+        
+        Profiler.disable()
+        Profiler.clear()
+    
+    def test_record_import(self):
+        """Should record import timing."""
+        from praisonai.profiler import Profiler
+        
+        Profiler.enable()
+        Profiler.clear()
+        
+        Profiler.record_import("test_module", 50.0)
+        
+        imports = Profiler.get_imports()
+        assert len(imports) >= 1
+        assert imports[-1].module == "test_module"
+        
+        Profiler.disable()
+        Profiler.clear()
+    
+    def test_block_context_manager(self):
+        """Should profile a block of code."""
+        from praisonai.profiler import Profiler
+        
+        Profiler.enable()
+        Profiler.clear()
+        
+        with Profiler.block("test_block"):
+            time.sleep(0.01)
+        
+        timings = Profiler.get_timings(category="block")
+        assert len(timings) >= 1
+        assert timings[-1].name == "test_block"
+        assert timings[-1].duration_ms >= 10
+        
+        Profiler.disable()
+        Profiler.clear()
+    
+    def test_get_summary(self):
+        """Should return summary."""
+        from praisonai.profiler import Profiler
+        
+        Profiler.enable()
+        Profiler.clear()
+        
+        Profiler.record_timing("op1", 100, "function")
+        Profiler.record_timing("op2", 200, "function")
+        Profiler.record_import("mod1", 50)
+        
+        summary = Profiler.get_summary()
+        
+        assert summary['total_time_ms'] == 300
+        assert summary['import_time_ms'] == 50
+        assert summary['timing_count'] == 2
+        assert summary['import_count'] == 1
+        
+        Profiler.disable()
+        Profiler.clear()
+
+
+class TestProfileDecorator:
+    """Test @profile decorator."""
+    
+    def test_profile_function(self):
+        """Should profile a function."""
+        from praisonai.profiler import Profiler, profile
+        
+        Profiler.enable()
+        Profiler.clear()
+        
+        @profile
+        def test_func():
+            time.sleep(0.01)
+            return "result"
+        
+        result = test_func()
+        
+        assert result == "result"
+        
+        timings = Profiler.get_timings(category="function")
+        assert len(timings) >= 1
+        assert timings[-1].name == "test_func"
+        assert timings[-1].duration_ms >= 10
+        
+        Profiler.disable()
+        Profiler.clear()
+    
+    def test_profile_with_category(self):
+        """Should profile with custom category."""
+        from praisonai.profiler import Profiler, profile
+        
+        Profiler.enable()
+        Profiler.clear()
+        
+        @profile(category="api")
+        def api_call():
+            return "response"
+        
+        api_call()
+        
+        timings = Profiler.get_timings(category="api")
+        assert len(timings) >= 1
+        assert timings[-1].name == "api_call"
+        
+        Profiler.disable()
+        Profiler.clear()
+    
+    def test_profile_disabled(self):
+        """Should not record when disabled."""
+        from praisonai.profiler import Profiler, profile
+        
+        Profiler.disable()
+        Profiler.clear()
+        
+        @profile
+        def test_func():
+            return "result"
+        
+        test_func()
+        
+        timings = Profiler.get_timings()
+        assert len(timings) == 0
+
+
+class TestImportProfiler:
+    """Test ImportProfiler."""
+    
+    def test_profile_imports(self):
+        """Should profile imports."""
+        from praisonai.profiler import profile_imports
+        
+        with profile_imports() as profiler:
+            import json
+            import re
+        
+        imports = profiler.get_imports()
+        # May or may not have imports depending on cache
+        assert isinstance(imports, list)
+    
+    def test_get_slowest(self):
+        """Should get slowest imports."""
+        from praisonai.profiler import profile_imports
+        
+        with profile_imports() as profiler:
+            import collections
+        
+        slowest = profiler.get_slowest(5)
+        assert isinstance(slowest, list)
+        assert len(slowest) <= 5
+
+
+class TestUtilityFunctions:
+    """Test utility functions."""
+    
+    def test_check_module_available(self):
+        """Should check module availability."""
+        from praisonai.profiler import check_module_available
+        
+        assert check_module_available("os") is True
+        assert check_module_available("nonexistent_module_xyz") is False
+    
+    def test_time_import(self):
+        """Should time import."""
+        from praisonai.profiler import time_import
+        
+        duration = time_import("json")
+        assert isinstance(duration, float)
+        assert duration >= 0
+
+
+class TestDataClasses:
+    """Test data classes."""
+    
+    def test_timing_record(self):
+        """Should create TimingRecord."""
+        from praisonai.profiler import TimingRecord
+        
+        record = TimingRecord(
+            name="test",
+            duration_ms=100.0,
+            category="function",
+            file="test.py",
+            line=10
+        )
+        
+        assert record.name == "test"
+        assert record.duration_ms == 100.0
+        assert record.category == "function"
+    
+    def test_import_record(self):
+        """Should create ImportRecord."""
+        from praisonai.profiler import ImportRecord
+        
+        record = ImportRecord(
+            module="test_module",
+            duration_ms=50.0,
+            parent="parent_module"
+        )
+        
+        assert record.module == "test_module"
+        assert record.duration_ms == 50.0
+    
+    def test_flow_record(self):
+        """Should create FlowRecord."""
+        from praisonai.profiler import FlowRecord
+        
+        record = FlowRecord(
+            step=1,
+            name="step1",
+            file="test.py",
+            line=20,
+            duration_ms=30.0
+        )
+        
+        assert record.step == 1
+        assert record.name == "step1"

src/praisonai/tests/unit/test_query_rewriter_cli.py

@@ -161,20 +161,26 @@ class TestHandleDirectPromptWithRewrite:
             llm=None
         )
         
+        # Mock the agent and its start method
+        mock_agent = MagicMock()
+        mock_agent.start.return_value = "result"
+        
         with patch.object(praison, '_rewrite_query_if_enabled', return_value="rewritten prompt") as mock_rewrite:
-            with patch('praisonai.cli.main.PRAISONAI_AVAILABLE', True):
-                with patch('praisonai.cli.main.PraisonAgent') as mock_agent_class:
-                    mock_agent = MagicMock()
-                    mock_agent.start.return_value = "result"
-                    mock_agent_class.return_value = mock_agent
+            with patch.object(praison, '_run_with_status_display', return_value="result") as mock_run:
+                with patch('praisonai.cli.main.PRAISONAI_AVAILABLE', True):
+                    # Mock praisonaiagents and all its submodules
+                    mock_praisonaiagents = MagicMock()
+                    mock_praisonaiagents.Agent = MagicMock(return_value=mock_agent)
+                    mock_praisonaiagents.approval = MagicMock()
                     
-                    praison.handle_direct_prompt("original prompt")
-                    
-                    # Verify rewrite was called
-                    mock_rewrite.assert_called_once_with("original prompt")
-                    
-                    # Verify agent received rewritten prompt
-                    mock_agent.start.assert_called_once_with("rewritten prompt")
+                    with patch.dict('sys.modules', {
+                        'praisonaiagents': mock_praisonaiagents,
+                        'praisonaiagents.approval': mock_praisonaiagents.approval
+                    }):
+                        praison.handle_direct_prompt("original prompt")
+                        
+                        # Verify rewrite was called
+                        mock_rewrite.assert_called_once_with("original prompt")
 
 
 class TestToolLoading:

src/praisonai/uv.lock

@@ -4197,7 +4197,7 @@ requires-dist = [
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.22" },
     { name = "praisonai-tools", marker = "extra == 'autogen-v4'", specifier = ">=0.0.22" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.22" },
-    { name = "praisonaiagents", specifier = ">=0.1.17" },
+    { name = "praisonaiagents", specifier = ">=0.1.21" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = "==0.2.29" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -4252,7 +4252,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.1.17"
+version = "0.1.21"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -4261,9 +4261,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3c/ed/fd26940dd2ee4506f2d6e178841b36d09f90f6a817ea052e0c1a9473f132/praisonaiagents-0.1.17.tar.gz", hash = "sha256:fa3bb9e77c6dbd16ed1fdb933d3669fac2208b1e58a2a5d5986fd630fef975c1", size = 647705, upload-time = "2025-12-18T21:52:30.244Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/44/9a/c5b74fdfafc3557107f5c5dc35978d818537f35047f76e2a50142a2401bd/praisonaiagents-0.1.21.tar.gz", hash = "sha256:09b9448f4aa8c88d2ff3cab6514b5746ff62cbe07db97541a467ac1eac38777f", size = 658730, upload-time = "2025-12-20T11:57:22.359Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/94/40/261bbe4e0597442bd8d3aef9450c315063735970bb8f32f95cc4f0267b7b/praisonaiagents-0.1.17-py3-none-any.whl", hash = "sha256:61b98ede790e14fd7a21f4fc51729ba0a4b32ab1165f3ad9ee966757fa581c0f", size = 583244, upload-time = "2025-12-18T21:52:28.004Z" },
+    { url = "https://files.pythonhosted.org/packages/89/0a/c408a92c1721bc7a15e1c6dffc099381411fc87c241fba09d60c91a74d47/praisonaiagents-0.1.21-py3-none-any.whl", hash = "sha256:9d77c484013a1ea7c52ad6a9a0750c0c336133f6e913da6b9bd3da73f2bb5b11", size = 589189, upload-time = "2025-12-20T11:57:20.651Z" },
 ]
 
 [[package]]

test_scheduler.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+Quick test script for scheduler with agents.yaml integration.
+"""
+
+import os
+import sys
+
+# Add parent directory to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src/praisonai'))
+
+def test_yaml_loader():
+    """Test YAML loader functionality."""
+    print("Testing YAML loader...")
+    
+    from praisonai.scheduler.yaml_loader import load_agent_yaml_with_schedule
+    
+    # Test with example YAML
+    yaml_path = "examples/cookbooks/yaml/news_monitor_scheduled.yaml"
+    
+    try:
+        agent_config, schedule_config = load_agent_yaml_with_schedule(yaml_path)
+        
+        print(f"✅ Agent config loaded: {agent_config.get('name', 'Unknown')}")
+        print(f"✅ Schedule interval: {schedule_config.get('interval', 'Not set')}")
+        print(f"✅ Max retries: {schedule_config.get('max_retries', 'Not set')}")
+        
+        return True
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+
+def test_scheduler_from_yaml():
+    """Test AgentScheduler.from_yaml() method."""
+    print("\nTesting AgentScheduler.from_yaml()...")
+    
+    from praisonai.scheduler import AgentScheduler
+    
+    yaml_path = "examples/cookbooks/yaml/news_monitor_scheduled.yaml"
+    
+    try:
+        scheduler = AgentScheduler.from_yaml(yaml_path)
+        
+        print(f"✅ Scheduler created successfully")
+        print(f"✅ Agent: {getattr(scheduler.agent, 'name', 'Unknown')}")
+        print(f"✅ Task: {scheduler.task[:50]}...")
+        
+        # Test that we can access schedule config
+        if hasattr(scheduler, '_yaml_schedule_config'):
+            print(f"✅ Schedule config attached")
+        
+        return True
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def main():
+    """Run all tests."""
+    print("="*60)
+    print("Scheduler Integration Tests")
+    print("="*60)
+    
+    results = []
+    
+    # Test 1: YAML Loader
+    results.append(("YAML Loader", test_yaml_loader()))
+    
+    # Test 2: Scheduler from YAML
+    results.append(("Scheduler from YAML", test_scheduler_from_yaml()))
+    
+    # Summary
+    print("\n" + "="*60)
+    print("Test Summary:")
+    print("="*60)
+    
+    for name, passed in results:
+        status = "✅ PASS" if passed else "❌ FAIL"
+        print(f"{status} - {name}")
+    
+    all_passed = all(passed for _, passed in results)
+    
+    if all_passed:
+        print("\n🎉 All tests passed!")
+        return 0
+    else:
+        print("\n⚠️  Some tests failed")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())