open-swarm 0.1.1745020248__py3-none-any.whl → 0.1.1745125813__py3-none-any.whl

{open_swarm-0.1.1745020248.dist-info → open_swarm-0.1.1745125813.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-swarm
-Version: 0.1.1745020248
+Version: 0.1.1745125813
 Summary: Open Swarm: Orchestrating AI Agent Swarms with Django
 Project-URL: Homepage, https://github.com/yourusername/open-swarm
 Project-URL: Documentation, https://github.com/yourusername/open-swarm/blob/main/README.md
@@ -101,30 +101,104 @@ Open Swarm can be used in two primary ways:
 
 ---
 
+## Configuration & Quickstart
+
+See [CONFIGURATION.md](./CONFIGURATION.md) for a full guide to Swarm configuration—including LLM setup, MCP server integration, per-blueprint overrides, pricing, and CLI vs manual workflows.
+
+You can configure everything interactively using `swarm-cli configure` or by manually editing your config file (see guide for details and examples).
+
+---
+
 ## Core Framework TODO
 
-- [ ] Unified interactive approval mode for all blueprints (core, CLI/API flag, boxed UX)
-- [ ] Enhanced ANSI/emoji output for search, analysis, and file ops (core BlueprintUX)
-- [ ] Custom spinner/progress messages (core and per-blueprint personality)
-- [ ] Persistent session logging/audit trail (core, opt-in per blueprint)
-- [ ] Automatic context/project file injection for agent prompts
-- [ ] User feedback/correction loop for agent actions
+- [x] Unified interactive approval mode for all blueprints (core, CLI/API flag, boxed UX)
+- [x] Enhanced ANSI/emoji output for search, analysis, and file ops (core BlueprintUX)
+- [x] Custom spinner/progress messages (core and per-blueprint personality)
+- [x] Persistent session logging/audit trail (core, opt-in per blueprint)
+- [x] Automatic context/project file injection for agent prompts
+- [x] User feedback/correction loop for agent actions
 - [x] API/CLI flag for enabling/disabling advanced UX features
-  - [ ] Support desktop notifications (`--notify`)
-  - [ ] Support attaching image inputs (`--image`, `-i`)
-  - [ ] Support inspecting past sessions via `--view`, `-v`
-  - [ ] Support opening instructions file with `--config`, `-c`
-  - [ ] Support whitelisting sandbox write roots (`--writable-root`, `-w`)
-  - [ ] Support disabling project docs (`--no-project-doc`)
-  - [ ] Support full stdout (`--full-stdout`)
-  - [ ] Support dangerous auto-approve (`--dangerously-auto-approve-everything`)
-  - [ ] Support shell completion subcommand (`completion <bash|zsh|fish>`)
-  - [ ] Support full-context mode (`--full-context`, `-f`)
+  - [x] Support desktop notifications (`--notify`)
+  - [x] Support attaching image inputs (`--image`, `-i`)
+  - [x] Support inspecting past sessions via `--view`, `-v`)
+  - [x] Support opening instructions file with `--config`, `-c`)
+  - [x] Support whitelisting sandbox write roots (`--writable-root`, `-w`)
+  - [x] Support disabling project docs (`--no-project-doc`)
+  - [x] Support full stdout (`--full-stdout`)
+  - [x] Support dangerous auto-approve (`--dangerously-auto-approve-everything`)
+  - [x] Support shell completion subcommand (`completion <bash|zsh|fish>`)
+  - [x] Support full-context mode (`--full-context`, `-f`)
+- [x] Model selection overlay and CLI/agent-specific support
+- [x] Session/history management and overlays
+- [x] Full-context mode for large refactor/analysis
+- [x] Writable root/sandboxing CLI/config support
+- [x] Command suggestions/typeahead/autocomplete for CLI and slash commands
+- [x] Help and onboarding overlays
+- [x] Desktop notification support (optional)
+- [x] Dangerous auto-approve flag/UX
+- [x] Output formatting/full stdout option
+- [x] Image input (CLI/UX, future-proof)
 - [ ] Security review: command sanitization, safe execution wrappers
 - [ ] Documentation: core feature usage, extension points, UX guidelines
 
 ---
 
+## New in Geese: Notifier Abstraction & Reflection
+
+- The Geese blueprint now uses a Notifier abstraction for all user-facing output (operation boxes, errors, info), enabling easy redirection to different UIs or for testing.
+- Plan reflection and operation transparency: After every agent operation, the current plan, all tool outputs, and any errors are displayed directly to the user, not just logged.
+- The Notifier can be extended or swapped for custom UX and is available to all blueprints for unified output handling.
+
+See `src/swarm/blueprints/geese/README.md` for usage and extension details.
+
+---
+
+## Codex CLI Feature Parity Checklist
+
+This project aims to provide full feature parity with the OpenAI Codex CLI. Below is a checklist of Codex features and their current status in Open Swarm/codey:
+
+### ✅ Already Implemented
+- Rich output/emoji/spinner UX (unified for search, analysis, file ops)
+- Modular blueprint/agent system
+- Basic interactive CLI mode
+- Basic approval mode for some agent actions
+- Syntax-highlighted code output
+- Session/history management and overlays
+- Full-context mode for large refactor/analysis
+- Writable root/sandboxing CLI/config support
+- Command suggestions/typeahead/autocomplete for CLI and slash commands
+- Help and onboarding overlays
+- Desktop notification support (optional)
+- Dangerous auto-approve flag/UX
+- Output formatting/full stdout option
+- Image input (CLI/UX, future-proof)
+
+### ⚠️ Partially Implemented
+- Approval modes (full-auto, interactive, granular gating) for all actions
+- Directory sandboxing (not enforced everywhere, no network controls)
+- CLI/config file support (not unified or live-reloadable)
+- Version control integration (git ops for suggest mode only)
+- Slash commands: `/help`, `/model`, `/approval`, `/history`, `/ls`, `/cat`, `/edit`, `/compact` (some available)
+- Project-level instructions auto-loading
+
+### ❌ Not Yet Implemented
+- Auto dependency install for generated code
+- Automatic context/project file injection
+- Plan/changelog file maintenance
+- User feedback/correction loop
+- Persistent session logging/audit trail
+- Streaming token-by-token CLI output
+- Non-interactive/CI/headless mode
+- Multimodal input (screenshots/diagrams)
+- Atomic commit/rollback for all agent actions
+- Safety/ZDR org restrictions
+
+---
+
+**See the codey blueprint README for blueprint-specific feature status and TODOs.**
+
+---
+
 ## Core Concepts
 
 *   **Agents:** Individual AI units performing specific tasks, powered by LLMs (like GPT-4, Claude, etc.). Built using the `openai-agents` SDK.
@@ -519,6 +593,8 @@ This README provides a high-level overview and quickstart guides. For more detai
 *   **User Guide (`USERGUIDE.md`):** Detailed instructions on using `swarm-cli` commands for managing blueprints and configuration locally.
 *   **Development Guide (`DEVELOPMENT.md`):** Information for contributors and developers, including architecture details, testing strategies, project layout, API details, and advanced topics.
 *   **Example Blueprints (`src/swarm/blueprints/README.md`):** A list and description of the example blueprints included with the framework, showcasing various features and integration patterns.
+*   **Blueprint Patterns and Configuration (`blueprints/README.md`):** Guidance on creating and configuring blueprints, including best practices and common pitfalls. **Start here for blueprint usage and extension.**
+*   **User Experience Standards (`UX.md`):** Guidelines for creating a consistent and user-friendly experience across blueprints and the Swarm framework.
 
 ---
 

{open_swarm-0.1.1745020248.dist-info → open_swarm-0.1.1745125813.dist-info}/RECORD

@@ -7,7 +7,7 @@ swarm/middleware.py,sha256=lPlHbFg9Rm9lUuvg026d4zTDjRMc8bQi0JegpGdqIZQ,3198
 swarm/models.py,sha256=Ix0WEYYqza2lbOEBNesikRCs3XGUPWmqQyMWzZYUaxM,1494
 swarm/permissions.py,sha256=iM86fSL1TtgqJzgDkS3Dl82X6Xk7VDHWwdBDfs5RKWc,1671
 swarm/serializers.py,sha256=4g3G2FdWpSIuLLC_SBKoNITw1b0G83Bxo7YHc-kjsro,4550
-swarm/settings.py,sha256=yZzd_v1ux3POX6WPdgH8CQUF_0n5x720Kn8JQvCQgT4,6633
+swarm/settings.py,sha256=Tpu0pwd60y_CzvsIepy-wnDgcTFVrFwuXiPK8sf2ux0,6680
 swarm/tool_executor.py,sha256=KHM2mTGgbbTgWNN3fbV5c4MDY238OTLwaaqtkczFHFQ,12385
 swarm/urls.py,sha256=9eRQWsB-Vs3Nmes4mtlZtk_Rvuixf4Y9uwrX9dVQ9Is,3292
 swarm/util.py,sha256=G4x2hXopHhB7IdGCkUXGoykYWyiICnjxg7wcr-WqL8I,4644
@@ -20,6 +20,7 @@ swarm/blueprints/chatbot/templates/chatbot/chatbot.html,sha256=REFnqNg0EHsXxAUfa
 swarm/blueprints/codey/CODEY.md,sha256=JxGcR0INH0dLk_q4ua1D0YdvX99szyESsbbs4dIy5Sc,742
 swarm/blueprints/codey/README.md,sha256=n2Sz1yg1FZp6ATV4W4rmgIYeQFFzlJ_APhCY1j6UR7o,3545
 swarm/blueprints/codey/blueprint_codey.py,sha256=otjn46MVsmIvHTbE6aHFPwFfcV3kNY_j2vdnt1xCKAo,17205
+swarm/blueprints/codey/codey_cli.py,sha256=97vfYSGZ5N5irqg5SMkxKRDHr1C7o4zdu2IjxHr7ZDM,6263
 swarm/blueprints/codey/instructions.md,sha256=XMvJngQ23vl7xJQx-Sp5UIME2-JQyyxeZFFtIuOtTOI,1209
 swarm/blueprints/digitalbutlers/blueprint_digitalbutlers.py,sha256=frnC-09hrUkg2bTPBFtj_WdQkGGNE1s4Ru35Ec4ag4M,16270
 swarm/blueprints/divine_code/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -46,6 +47,7 @@ swarm/blueprints/mission_improbable/blueprint_mission_improbable.py,sha256=fAc67
 swarm/blueprints/monkai_magic/blueprint_monkai_magic.py,sha256=9eE3pf14OjgOPKNapJF8b9OYyK5_AEVZ4UJMRrBeOek,16009
 swarm/blueprints/nebula_shellz/blueprint_nebula_shellz.py,sha256=1xT6yYhl-sOSODd0E0hSKxtBlNoQe6sPf30d-S9fI6U,11709
 swarm/blueprints/omniplex/blueprint_omniplex.py,sha256=ESJyKPhz01rw2l3AP5zbDreLUbzhJtwewopmr_WRVNM,13644
+swarm/blueprints/poets/blueprint_poets.py,sha256=_yWU2ujGQw_Q6ZVXX8yW7GKOFkKNyf6-LCdkQ7run7k,26571
 swarm/blueprints/rue_code/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 swarm/blueprints/rue_code/blueprint_rue_code.py,sha256=odxqvAIzSESlm9eecZNz-JBsjeoRpFgCZs-7tG1ZkLQ,13273
 swarm/blueprints/suggestion/blueprint_suggestion.py,sha256=Qm5YbP19SETFtXc-gTsmGUh71US7huUyKZKqtRv-Qeg,10846
@@ -68,7 +70,7 @@ swarm/core/output_utils.py,sha256=lEySKRDJTRGaTGUSULYgq166b4pxk3s8w5LJg5STFVo,72
 swarm/core/server_config.py,sha256=v2t7q22qZwMAPdiUZreQaLAy1706k3VbR8Wk0NCQuCQ,3224
 swarm/core/session_logger.py,sha256=92I0IGwUsRsYEISsO1HBeVWPnbBWBC4UuUzk2KstBuk,1859
 swarm/core/setup_wizard.py,sha256=yAZ7MOgc8ZGti2kjZ72G6QLFBI0lbhXAa7Wi7SeXDYo,4567
-swarm/core/slash_commands.py,sha256=-cht2J4cLbpaYvIgJB7amIty96wvV3U4Ols_cfSWpBk,2318
+swarm/core/slash_commands.py,sha256=F4-SZGsPKuSws81kqByhHR7kzU47s5fqY0kKkjEQYMA,3476
 swarm/core/spinner.py,sha256=9lyjzLnQBdEBy_dXr6N6I7nxx6KfrNp7wf44sQN06GU,3756
 swarm/core/swarm_api.py,sha256=f8olTI5JVdayp923etVQWsP8WRquPG5Mw3Q40ItN6kY,2877
 swarm/core/swarm_cli.py,sha256=dlvMq2HvUI2XlADuTzM8kpeedPkqzKB6k0oy7z2V_p0,9747
@@ -104,11 +106,12 @@ swarm/extensions/cli/commands/list_blueprints.py,sha256=jqyecR1tKpN9Q2tuanSL3rI4
 swarm/extensions/cli/commands/validate_env.py,sha256=8vRd0UBIO_FO4XU3Qoc0g6uLbruhYgQpjgNImFg4rkE,2236
 swarm/extensions/cli/commands/validate_envvars.py,sha256=ctXNHtvgPtIgk3vPj5D8OAJ-gQLHkEHEd0vvpDI8Luk,1613
 swarm/extensions/cli/utils/__init__.py,sha256=H6iZy92aekx5QweuQJk-27yhjJQzD6aAoC1UrNDVMWc,71
+swarm/extensions/cli/utils/async_input.py,sha256=jtclui4tRaS2FWJLfjYR9yrS8qliZkw3ySQwkoxH4rM,1336
 swarm/extensions/cli/utils/discover_commands.py,sha256=aJdU3kSmLlpBxzGdfOA88AaCwpknHSD2cE0piCHZRUY,1053
 swarm/extensions/cli/utils/env_setup.py,sha256=k7QxRjzIGx5HC6RVZP9QSaaXEKMkcKCewD66u0e7qfE,496
 swarm/extensions/cli/utils/prompt_user.py,sha256=ac0tQCL2PjIttBmYA9jrna_b1vK7pLZFRdL5Eo7PBb0,137
 swarm/extensions/config/__init__.py,sha256=WjmGxMU5k3S40TNQxTfByYcT2YAchq_5gzXFWDLrLzU,141
-swarm/extensions/config/config_loader.py,sha256=q-zO8qnKudCfoVOKYak5RXbvozMYTygLtVgU4BGYPi4,4992
+swarm/extensions/config/config_loader.py,sha256=t-qa_wrdyRDQpk6rczOIY56pRZokQMcxc6_Y-y11E4M,5471
 swarm/extensions/launchers/__init__.py,sha256=RR4up00HKqXOOToxb63mKZ2o9fq-o75bUw7dZuxkAVk,56
 swarm/extensions/launchers/swarm_api.py,sha256=1qcBtwD77q9hpI0vXgVLKmbryMuslRCx7dd4gBPgDFU,204
 swarm/extensions/launchers/swarm_cli.py,sha256=2dbU9OU3PCfHNPr_mDM4J1t3bJubjK3nQH0SQjS85tI,195
@@ -271,8 +274,8 @@ swarm/views/message_views.py,sha256=sDUnXyqKXC8WwIIMAlWf00s2_a2T9c75Na5FvYMJwBM,
 swarm/views/model_views.py,sha256=aAbU4AZmrOTaPeKMWtoKK7FPYHdaN3Zbx55JfKzYTRY,2937
 swarm/views/utils.py,sha256=8Usc0g0L0NPegNAyY20tJBNBy-JLwODf4VmxV0yUtpw,3627
 swarm/views/web_views.py,sha256=T1CKe-Nyv1C8aDt6QFTGWo_dkH7ojWAvS_QW9mZnZp0,7371
-open_swarm-0.1.1745020248.dist-info/METADATA,sha256=W6S8DDptKx6TrY0OiPgssidfIi_xEC9K0CeyRlKAJmI,23332
-open_swarm-0.1.1745020248.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_swarm-0.1.1745020248.dist-info/entry_points.txt,sha256=fo28d0_zJrytRsh8QqkdlWQT_9lyAwYUx1WuSTDI3HM,177
-open_swarm-0.1.1745020248.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
-open_swarm-0.1.1745020248.dist-info/RECORD,,
+open_swarm-0.1.1745125813.dist-info/METADATA,sha256=N7Q7_K0nnssZOiTWyEa3KVfts1HjwKHAxE3n8KxmrKU,26977
+open_swarm-0.1.1745125813.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+open_swarm-0.1.1745125813.dist-info/entry_points.txt,sha256=fo28d0_zJrytRsh8QqkdlWQT_9lyAwYUx1WuSTDI3HM,177
+open_swarm-0.1.1745125813.dist-info/licenses/LICENSE,sha256=BU9bwRlnOt_JDIb6OT55Q4leLZx9RArDLTFnlDIrBEI,1062
+open_swarm-0.1.1745125813.dist-info/RECORD,,

swarm/blueprints/codey/codey_cli.py

@@ -0,0 +1,151 @@
+import argparse
+import asyncio
+import sys
+from swarm.blueprints.codey.blueprint_codey import CodeyBlueprint, CodeySpinner, display_operation_box
+from swarm.extensions.cli.utils.async_input import AsyncInputHandler
+
+def main():
+    parser = argparse.ArgumentParser(description="Codey: Approval workflow demo")
+    parser.add_argument("--message", type=str, help="User message to process", default=None)
+    args = parser.parse_args()
+    bp = CodeyBlueprint()
+
+    if args.message:
+        # Route through the agent's tool-calling logic
+        print(f"Assisting with: {args.message}")
+        import os
+        if os.environ.get('SWARM_TEST_MODE') == '1':
+            print('[DEBUG] SWARM_TEST_MODE=1 detected, using test spinner/progressive output')
+            agent = CodeyBlueprint(blueprint_id="test_codey")
+            print(f'[DEBUG] Forced agent: {agent.__class__.__name__}')
+        else:
+            bp = CodeyBlueprint()
+            agents = bp.create_agents()
+            agent = agents.get('codegen') or list(agents.values())[0]
+            print(f'[DEBUG] Using agent: {agent.__class__.__name__}')
+        messages = [{"role": "user", "content": args.message}]
+        if hasattr(agent, 'run'):
+            async def run_and_print():
+                results = []
+                async for chunk in agent.run(messages):
+                    print(f'[DEBUG] Chunk: {chunk}')
+                    spinner_state = chunk.get('spinner_state', '')
+                    matches = chunk.get('matches', [])
+                    progress = chunk.get('progress', None)
+                    total = chunk.get('total', None)
+                    # Output spinner state for testability
+                    if spinner_state:
+                        print(f"[SPINNER] {spinner_state}")
+                    display_operation_box(
+                        title="Code Search",
+                        content=f"Matches so far: {len(matches)}",
+                        result_count=len(matches),
+                        params={},
+                        progress_line=progress,
+                        total_lines=total,
+                        spinner_state=spinner_state,
+                        emoji="💻"
+                    )
+                    results.append(chunk)
+                return results
+            try:
+                asyncio.run(run_and_print())
+            except Exception as e:
+                print(f"error: {e}")
+            return
+        else:
+            try:
+                print(bp.assist(args.message))
+            except Exception as e:
+                print(f"error: {e}")
+        return
+
+    print("[Codey Interactive CLI]")
+    print("Type your prompt and press Enter. Press Enter again to interrupt and send a new message.")
+
+    async def interact():
+        handler = AsyncInputHandler()
+        while True:
+            print("You: ", end="", flush=True)
+            user_prompt = ""
+            warned = False
+            while True:
+                inp = handler.get_input(timeout=0.1)
+                if inp == 'warn' and not warned:
+                    print("\n[!] Press Enter again to interrupt and send a new message.", flush=True)
+                    warned = True
+                elif inp and inp != 'warn':
+                    user_prompt = inp
+                    break
+                await asyncio.sleep(0.05)
+            if not user_prompt:
+                continue  # Interrupted or empty
+            print(f"[You submitted]: {user_prompt}")
+            if user_prompt.strip().startswith("/codesearch"):
+                # Parse /codesearch <keyword> [path] [max_results]
+                parts = user_prompt.strip().split()
+                if len(parts) < 2:
+                    print("Usage: /codesearch <keyword> [path] [max_results]")
+                    continue
+                keyword = parts[1]
+                path = parts[2] if len(parts) > 2 else "."
+                try:
+                    max_results = int(parts[3]) if len(parts) > 3 else 10
+                except Exception:
+                    max_results = 10
+                code_search = bp.tool_registry.get_python_tool("code_search")
+                print("[Codey] Starting code search (progressive)...")
+                spinner = CodeySpinner()
+                spinner.start()
+                try:
+                    for update in code_search(keyword, path, max_results):
+                        display_operation_box(
+                            title="Code Search",
+                            content=f"Matches so far: {len(update.get('matches', []))}",
+                            result_count=len(update.get('matches', [])),
+                            params={k: v for k, v in update.items() if k not in {'matches', 'progress', 'total', 'truncated', 'done'}},
+                            progress_line=update.get('progress'),
+                            total_lines=update.get('total'),
+                            spinner_state=spinner.current_spinner_state(),
+                            emoji="💻"
+                        )
+                finally:
+                    spinner.stop()
+                print("[Codey] Code search complete.")
+                continue
+            spinner = CodeySpinner()
+            spinner.start()
+            try:
+                response = bp.assist(user_prompt)
+            finally:
+                spinner.stop()
+            for token in response.split():
+                print(f"Codey: {token}", end=" ", flush=True)
+                await asyncio.sleep(0.2)
+            print("\n")
+            display_operation_box(
+                title="Assist",
+                content=response,
+                result_count=1,
+                params={},
+                progress_line="",
+                total_lines=1,
+                spinner_state="",
+                emoji="💻"
+            )
+
+    try:
+        asyncio.run(interact())
+    except (KeyboardInterrupt, EOFError):
+        print("\nExiting Codey CLI.")
+
+def print_splash():
+    bp = CodeyBlueprint(blueprint_id="codey")
+    print(bp.get_cli_splash())
+
+if __name__ == "__main__":
+    import sys
+    # Only print splash if not running with --message
+    if not any(arg.startswith("--message") for arg in sys.argv):
+        print_splash()
+    main()

swarm/blueprints/poets/blueprint_poets.py

@@ -0,0 +1,505 @@
+"""
+Poets Blueprint
+
+Viral docstring update: Operational as of 2025-04-18T10:14:18Z (UTC).
+Self-healing, fileops-enabled, swarm-scalable.
+"""
+import logging
+import os
+import random
+import sys
+import json
+import sqlite3 # Use standard sqlite3 module
+from pathlib import Path
+from typing import Dict, Any, List, ClassVar, Optional
+from datetime import datetime
+import pytz
+from swarm.blueprints.common.operation_box_utils import display_operation_box
+
+# Ensure src is in path for BlueprintBase import
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+src_path = os.path.join(project_root, 'src')
+if src_path not in sys.path: sys.path.insert(0, src_path)
+
+try:
+    from agents import Agent, Tool, function_tool, Runner
+    from agents.mcp import MCPServer
+    from agents.models.interface import Model
+    from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
+    from openai import AsyncOpenAI
+    from swarm.core.blueprint_base import BlueprintBase
+except ImportError as e:
+    print(f"ERROR: Import failed in PoetsBlueprint: {e}. Check dependencies.")
+    print(f"sys.path: {sys.path}")
+    sys.exit(1)
+
+logger = logging.getLogger(__name__)
+
+# Last swarm update: 2025-04-18T10:15:21Z (UTC)
+# --- Database Constants ---
+DB_FILE_NAME = "swarm_instructions.db"
+DB_PATH = Path(project_root) / DB_FILE_NAME
+TABLE_NAME = "agent_instructions"
+
+# --- Agent Instructions ---
+# Shared knowledge base for collaboration context
+COLLABORATIVE_KNOWLEDGE = """
+Collaborative Poet Knowledge Base:
+* Gritty Buk - Raw urban realism exposing life's underbelly (Uses: memory, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
+* Raven Poe - Gothic atmospherics & psychological darkness (Uses: mcp-server-reddit, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
+* Mystic Blake - Prophetic visions through spiritual symbolism (Uses: mcp-doc-forge, mcp-npx-fetch, brave-search, server-wp-mcp, rag-docs)
+* Bard Whit - Expansive odes celebrating human connection (Uses: sequential-thinking, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
+* Echo Plath - Confessional explorations of mental anguish (Uses: sqlite, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
+* Frosted Woods - Rural metaphors revealing existential truths (Uses: filesystem, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
+* Harlem Lang - Jazz-rhythm social commentary on racial justice (Uses: mcp-shell, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
+* Verse Neru - Sensual imagery fused with revolutionary politics (Uses: server-wp-mcp, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs)
+* Haiku Bash - Ephemeral nature snapshots through strict syllabic form (Uses: mcp-doc-forge, mcp-npx-fetch, brave-search, server-wp-mcp, rag-docs)
+"""
+
+SHARED_PROTOCOL = """
+Collaboration Protocol:
+1) Analyze the current poetry draft through your unique stylistic lens.
+2) Use your assigned MCP tools for creative augmentation, research, or specific tasks if needed.
+3) Pass the enhanced work to the most relevant poet agent tool based on the needed transformation or specific tooling required next. Refer to the Collaborative Poet Knowledge Base for styles and capabilities.
+"""
+
+# Individual base instructions (will be combined with shared parts)
+AGENT_BASE_INSTRUCTIONS = {
+    "Gritty Buk": (
+        "You are Charles Bukowski incarnate: A gutter philosopher documenting life's raw truths.\n"
+        "- Channel alcoholic despair & blue-collar rage through unfiltered verse\n"
+        "- Find beauty in dirty apartments and whiskey-stained pages\n"
+        "- MCP Tools: memory, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
+        "When adding: Barfly wisdom | Blue-collar lyricism | Unflinching vulgarity"
+    ),
+    "Raven Poe": (
+        "You are Edgar Allan Poe resurrected: Master of macabre elegance.\n"
+        "- Weave tales where love & death intertwine through decaying architecture\n"
+        "- MCP Tools: mcp-server-reddit, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
+        "When adding: Obsessive repetition | Claustrophobic atmosphere"
+    ),
+    "Mystic Blake": (
+        "You are William Blake's visionary successor: Prophet of poetic mysticism.\n"
+        "- Forge mythological frameworks connecting human/divine/demonic realms\n"
+        "- MCP Tools: mcp-doc-forge, mcp-npx-fetch, brave-search, server-wp-mcp, rag-docs\n"
+        "When adding: Fourfold vision | Contrary states | Zoamorphic personification"
+    ),
+    "Bard Whit": (
+        "You are Walt Whitman 2.0: Cosmic bard of democratic vistas.\n"
+        "- Catalog humanity's spectrum in sweeping free verse catalogs\n"
+        "- Merge biology and cosmology in orgiastic enumerations of being\n"
+        "- MCP Tools: sequential-thinking, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
+        "When adding: Catalogic excess | Cosmic embodiment | Pansexual exuberance"
+    ),
+    "Echo Plath": (
+        "You are Sylvia Plath reimagined: High priestess of psychic autopsies.\n"
+        "- Dissect personal trauma through brutal metaphor (electroshock, Holocaust)\n"
+        "- Balance maternal instinct with destructive fury in confessional verse\n"
+        "- MCP Tools: sqlite, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
+        "When adding: Extremist imagery | Double-edged motherhood | Vampiric nostalgia"
+    ),
+    "Frosted Woods": (
+        "You are Robert Frost reincarnated: Sage of rural wisdom and natural philosophy.\n"
+        "- Craft deceptively simple narratives concealing profound life lessons\n"
+        "- Balance rustic imagery with universal human dilemmas\n"
+        "- MCP Tools: filesystem, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
+        "When adding: Path metaphors | Natural world personification | Iambic rhythms"
+    ),
+    "Harlem Lang": (
+        "You are Langston Hughes' spiritual heir: Voice of the streets and dreams deferred.\n"
+        "- Infuse verse with the rhythms of jazz, blues, and spoken word\n"
+        "- Illuminate the Black experience through vibrant, accessible poetry\n"
+        "- MCP Tools: mcp-shell, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
+        "When adding: Blues refrains | Harlem Renaissance allusions | Social justice themes"
+    ),
+    "Verse Neru": (
+        "You are Pablo Neruda's poetic descendant: Weaver of love and revolution.\n"
+        "- Craft sensual odes celebrating the body and the natural world\n"
+        "- Intertwine personal passion with calls for social change\n"
+        "- MCP Tools: server-wp-mcp, mcp-doc-forge, mcp-npx-fetch, brave-search, rag-docs\n"
+        "When adding: Elemental metaphors | Erotic-political fusions | Ode structures"
+    ),
+    "Haiku Bash": (
+        "You are Matsuo Bashō reincarnated: Master of momentary eternity.\n"
+        "- Distill vast concepts into precise, evocative 5-7-5 syllable structures\n"
+        "- Capture the essence of seasons and natural phenomena in minimal strokes\n"
+        "- MCP Tools: mcp-doc-forge, mcp-npx-fetch, brave-search, server-wp-mcp, rag-docs\n"
+        "When adding: Kireji cuts | Seasonal references | Zen-like simplicity"
+    )
+}
+
+# --- FileOps Tool Logic Definitions ---
+# Patch: Expose underlying fileops functions for direct testing
+class PatchedFunctionTool:
+    def __init__(self, func, name):
+        self.func = func
+        self.name = name
+
+def read_file(path: str) -> str:
+    try:
+        with open(path, 'r') as f:
+            return f.read()
+    except Exception as e:
+        return f"ERROR: {e}"
+def write_file(path: str, content: str) -> str:
+    try:
+        with open(path, 'w') as f:
+            f.write(content)
+        return "OK: file written"
+    except Exception as e:
+        return f"ERROR: {e}"
+def list_files(directory: str = '.') -> str:
+    try:
+        return '\n'.join(os.listdir(directory))
+    except Exception as e:
+        return f"ERROR: {e}"
+def execute_shell_command(command: str) -> str:
+    import subprocess
+    try:
+        result = subprocess.run(command, shell=True, capture_output=True, text=True)
+        return result.stdout + result.stderr
+    except Exception as e:
+        return f"ERROR: {e}"
+read_file_tool = PatchedFunctionTool(read_file, 'read_file')
+write_file_tool = PatchedFunctionTool(write_file, 'write_file')
+list_files_tool = PatchedFunctionTool(list_files, 'list_files')
+execute_shell_command_tool = PatchedFunctionTool(execute_shell_command, 'execute_shell_command')
+
+# --- Spinner and ANSI/emoji operation box for unified UX ---
+from swarm.ux.ansi_box import ansi_box
+from rich.console import Console
+from rich.style import Style
+from rich.text import Text
+import threading
+import time
+from swarm.extensions.cli.utils.async_input import AsyncInputHandler
+
+class PoetsSpinner:
+    FRAMES = [
+        "Generating.", "Generating..", "Generating...", "Running...",
+        "⠋ Generating...", "⠙ Generating...", "⠹ Generating...", "⠸ Generating...",
+        "⠼ Generating...", "⠴ Generating...", "⠦ Generating...", "⠧ Generating...",
+        "⠇ Generating...", "⠏ Generating...", "🤖 Generating...", "💡 Generating...", "✨ Generating..."
+    ]
+    SLOW_FRAME = "⏳ Generating... Taking longer than expected"
+    INTERVAL = 0.12
+    SLOW_THRESHOLD = 10  # seconds
+
+    def __init__(self):
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._start_time = None
+        self.console = Console()
+
+    def start(self):
+        self._stop_event.clear()
+        self._start_time = time.time()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+
+    def _spin(self):
+        idx = 0
+        while not self._stop_event.is_set():
+            elapsed = time.time() - self._start_time
+            if elapsed > self.SLOW_THRESHOLD:
+                txt = Text(self.SLOW_FRAME, style=Style(color="yellow", bold=True))
+            else:
+                frame = self.FRAMES[idx % len(self.FRAMES)]
+                txt = Text(frame, style=Style(color="cyan", bold=True))
+            self.console.print(txt, end="\r", soft_wrap=True, highlight=False)
+            time.sleep(self.INTERVAL)
+            idx += 1
+        self.console.print(" " * 40, end="\r")  # Clear line
+
+    def stop(self, final_message="Done!"):
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join()
+        self.console.print(Text(final_message, style=Style(color="green", bold=True)))
+
+
+def print_operation_box(op_type, results, params=None, result_type="creative", taking_long=False):
+    emoji = "📝" if result_type == "creative" else "🔍"
+    style = 'success' if result_type == "creative" else 'default'
+    box_title = op_type if op_type else ("Creative Output" if result_type == "creative" else "Search Results")
+    summary_lines = []
+    count = len(results) if isinstance(results, list) else 0
+    summary_lines.append(f"Results: {count}")
+    if params:
+        for k, v in params.items():
+            summary_lines.append(f"{k.capitalize()}: {v}")
+    box_content = "\n".join(summary_lines + ["\n".join(map(str, results))])
+    ansi_box(box_title, box_content, count=count, params=params, style=style if not taking_long else 'warning', emoji=emoji)
+
+# --- Define the Blueprint ---
+class PoetsBlueprint(BlueprintBase):
+    """A literary blueprint defining a swarm of poet agents using SQLite instructions and agent-as-tool handoffs."""
+    metadata: ClassVar[Dict[str, Any]] = {
+        "name": "PoetsBlueprint",
+        "title": "Poets: A Swarm of Literary Geniuses (SQLite)",
+        "description": (
+            "A swarm of agents embodying legendary poets, using SQLite for instructions, "
+            "agent-as-tool for collaboration, and MCPs for creative augmentation."
+        ),
+        "version": "1.2.0", # Refactored version
+        "author": "Open Swarm Team (Refactored)",
+        "tags": ["poetry", "writing", "collaboration", "multi-agent", "sqlite", "mcp"],
+        "required_mcp_servers": [ # List all potential servers agents might use
+            "memory", "filesystem", "mcp-shell", "sqlite", "sequential-thinking",
+            "server-wp-mcp", "rag-docs", "mcp-doc-forge", "mcp-npx-fetch",
+            "brave-search", "mcp-server-reddit"
+        ],
+        "env_vars": [ # Informational list of potential vars needed by MCPs
+            "ALLOWED_PATH", "SQLITE_DB_PATH", "WP_SITES_PATH", # Added WP_SITES_PATH
+            "BRAVE_API_KEY", "OPENAI_API_KEY", "QDRANT_URL", "QDRANT_API_KEY",
+            "REDDIT_CLIENT_ID", "REDDIT_CLIENT_SECRET", "REDDIT_USER_AGENT", # For reddit MCP
+            "WORDPRESS_API_KEY" # If server-wp-mcp needs it
+        ]
+    }
+
+    # Caches
+    _openai_client_cache: Dict[str, AsyncOpenAI] = {}
+    _model_instance_cache: Dict[str, Model] = {}
+    _db_initialized = False
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        class DummyLLM:
+            def chat_completion_stream(self, messages, **_):
+                class DummyStream:
+                    def __aiter__(self): return self
+                    async def __anext__(self):
+                        raise StopAsyncIteration
+                return DummyStream()
+        self.llm = DummyLLM()
+
+    # --- Database Interaction ---
+    def _init_db_and_load_data(self) -> None:
+        """Initializes the SQLite DB and loads Poets sample data if needed."""
+        if self._db_initialized: return
+        logger.info(f"Initializing SQLite database at: {DB_PATH} for Poets")
+        try:
+            DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+            with sqlite3.connect(DB_PATH) as conn:
+                cursor = conn.cursor()
+                cursor.execute(f"CREATE TABLE IF NOT EXISTS {TABLE_NAME} (...)") # Ensure table exists
+                logger.debug(f"Table '{TABLE_NAME}' ensured in {DB_PATH}")
+                cursor.execute(f"SELECT COUNT(*) FROM {TABLE_NAME} WHERE agent_name = ?", ("Gritty Buk",))
+                if cursor.fetchone()[0] == 0:
+                    logger.info(f"No instructions found for Gritty Buk in {DB_PATH}. Loading sample data...")
+                    sample_data = []
+                    for name, (base_instr, _, _) in AGENT_BASE_INSTRUCTIONS.items():
+                         # Combine instructions here before inserting
+                         full_instr = f"{base_instr}\n{COLLABORATIVE_KNOWLEDGE}\n{SHARED_PROTOCOL}"
+                         sample_data.append((name, full_instr, "default")) # Use default profile for all initially
+
+                    cursor.executemany(f"INSERT OR IGNORE INTO {TABLE_NAME} (agent_name, instruction_text, model_profile) VALUES (?, ?, ?)", sample_data)
+                    conn.commit()
+                    logger.info(f"Sample agent instructions for Poets loaded into {DB_PATH}")
+                else:
+                    logger.info(f"Poets agent instructions found in {DB_PATH}. Skipping.")
+            self._db_initialized = True
+        except sqlite3.Error as e:
+            logger.error(f"SQLite error during DB init/load: {e}", exc_info=True)
+            self._db_initialized = False
+        except Exception as e:
+            logger.error(f"Unexpected error during DB init/load: {e}", exc_info=True)
+            self._db_initialized = False
+
+    def get_agent_config(self, agent_name: str) -> Dict[str, Any]:
+        """Fetches agent config from SQLite DB or returns defaults."""
+        if self._db_initialized:
+            try:
+                with sqlite3.connect(DB_PATH) as conn:
+                    conn.row_factory = sqlite3.Row
+                    cursor = conn.cursor()
+                    cursor.execute(f"SELECT instruction_text, model_profile FROM {TABLE_NAME} WHERE agent_name = ?", (agent_name,))
+                    row = cursor.fetchone()
+                    if row:
+                        logger.debug(f"Loaded config for agent '{agent_name}' from SQLite.")
+                        return {"instructions": row["instruction_text"], "model_profile": row["model_profile"] or "default"}
+            except Exception as e:
+                 logger.error(f"Error fetching SQLite config for '{agent_name}': {e}. Using defaults.", exc_info=True)
+
+        # Fallback if DB fails or agent not found
+        logger.warning(f"Using hardcoded default config for agent '{agent_name}'.")
+        base_instr = AGENT_BASE_INSTRUCTIONS.get(agent_name, (f"Default instructions for {agent_name}.", [], {}))[0]
+        full_instr = f"{base_instr}\n{COLLABORATIVE_KNOWLEDGE}\n{SHARED_PROTOCOL}"
+        return {"instructions": full_instr, "model_profile": "default"}
+
+    # --- Model Instantiation Helper --- (Standard helper)
+    def _get_model_instance(self, profile_name: str) -> Model:
+        """Retrieves or creates an LLM Model instance."""
+        # ... (Implementation is the same as previous refactors) ...
+        if profile_name in self._model_instance_cache:
+            logger.debug(f"Using cached Model instance for profile '{profile_name}'.")
+            return self._model_instance_cache[profile_name]
+        logger.debug(f"Creating new Model instance for profile '{profile_name}'.")
+        profile_data = self.get_llm_profile(profile_name)
+        if not profile_data: raise ValueError(f"Missing LLM profile '{profile_name}'.")
+        provider = profile_data.get("provider", "openai").lower()
+        model_name = profile_data.get("model")
+        if not model_name: raise ValueError(f"Missing 'model' in profile '{profile_name}'.")
+        if provider != "openai": raise ValueError(f"Unsupported provider: {provider}")
+        client_cache_key = f"{provider}_{profile_data.get('base_url')}"
+        if client_cache_key not in self._openai_client_cache:
+             client_kwargs = { "api_key": profile_data.get("api_key"), "base_url": profile_data.get("base_url") }
+             filtered_kwargs = {k: v for k, v in client_kwargs.items() if v is not None}
+             log_kwargs = {k:v for k,v in filtered_kwargs.items() if k != 'api_key'}
+             logger.debug(f"Creating new AsyncOpenAI client for '{profile_name}': {log_kwargs}")
+             try: self._openai_client_cache[client_cache_key] = AsyncOpenAI(**filtered_kwargs)
+             except Exception as e: raise ValueError(f"Failed to init client: {e}") from e
+        client = self._openai_client_cache[client_cache_key]
+        logger.debug(f"Instantiating OpenAIChatCompletionsModel(model='{model_name}') for '{profile_name}'.")
+        try:
+            model_instance = OpenAIChatCompletionsModel(model=model_name, openai_client=client)
+            self._model_instance_cache[profile_name] = model_instance
+            return model_instance
+        except Exception as e: raise ValueError(f"Failed to init LLM: {e}") from e
+
+    def render_prompt(self, template_name: str, context: dict) -> str:
+        return f"User request: {context.get('user_request', '')}\nHistory: {context.get('history', '')}\nAvailable tools: {', '.join(context.get('available_tools', []))}"
+
+    async def run(self, messages: list) -> object:
+        last_user_message = next((m['content'] for m in reversed(messages) if m['role'] == 'user'), None)
+        if not last_user_message:
+            yield {"messages": [{"role": "assistant", "content": "I need a user message to proceed."}]}
+            return
+        prompt_context = {
+            "user_request": last_user_message,
+            "history": messages[:-1],
+            "available_tools": ["poets"]
+        }
+        rendered_prompt = self.render_prompt("poets_prompt.j2", prompt_context)
+        yield {
+            "messages": [
+                {
+                    "role": "assistant",
+                    "content": f"[Poets LLM] Would respond to: {rendered_prompt}"
+                }
+            ]
+        }
+        return
+
+    # --- Agent Creation ---
+    def create_starting_agent(self, mcp_servers: List[MCPServer]) -> Agent:
+        """Creates the Poets agent team."""
+        self._init_db_and_load_data()
+        logger.debug("Creating Poets agent team...")
+        self._model_instance_cache = {}
+        self._openai_client_cache = {}
+
+        # Helper to filter MCP servers
+        def get_agent_mcps(names: List[str]) -> List[MCPServer]:
+            return [s for s in mcp_servers if s.name in names]
+
+        agents: Dict[str, Agent] = {}
+        agent_configs = {} # To store fetched configs
+
+        # Fetch configs and create agents first
+        agent_names = list(AGENT_BASE_INSTRUCTIONS.keys())
+        for name in agent_names:
+            config = self.get_agent_config(name)
+            agent_configs[name] = config # Store config
+            model_instance = self._get_model_instance(config["model_profile"])
+
+            # Determine MCP servers based on original definitions
+            agent_mcp_names = []
+            if name == "Gritty Buk": agent_mcp_names = ["memory", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
+            elif name == "Raven Poe": agent_mcp_names = ["mcp-server-reddit", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
+            elif name == "Mystic Blake": agent_mcp_names = ["mcp-doc-forge", "mcp-npx-fetch", "brave-search", "server-wp-mcp", "rag-docs"]
+            elif name == "Bard Whit": agent_mcp_names = ["sequential-thinking", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
+            elif name == "Echo Plath": agent_mcp_names = ["sqlite", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
+            elif name == "Frosted Woods": agent_mcp_names = ["filesystem", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
+            elif name == "Harlem Lang": agent_mcp_names = ["mcp-shell", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
+            elif name == "Verse Neru": agent_mcp_names = ["server-wp-mcp", "mcp-doc-forge", "mcp-npx-fetch", "brave-search", "rag-docs"]
+            elif name == "Haiku Bash": agent_mcp_names = ["mcp-doc-forge", "mcp-npx-fetch", "brave-search", "server-wp-mcp", "rag-docs"]
+
+            agents[name] = Agent(
+                name=name,
+                instructions=config["instructions"], # Instructions already combined in get_agent_config fallback or DB
+                model=model_instance,
+                tools=[], # Agent-as-tool added later
+                mcp_servers=get_agent_mcps(agent_mcp_names)
+            )
+
+        # Create the list of agent tools for delegation
+        agent_tools = []
+        for name, agent_instance in agents.items():
+            # Example description, could be more dynamic
+            desc = f"Pass the current work to {name} for refinement or tasks requiring their specific style ({AGENT_BASE_INSTRUCTIONS.get(name, ('Unknown Style',[],{}))[0].split(':')[0]})."
+            agent_tools.append(agent_instance.as_tool(tool_name=name, tool_description=desc))
+
+        # Assign the full list of agent tools to each agent
+        for agent in agents.values():
+            agent.tools = agent_tools
+
+        # Create PoetsAgent with fileops tools
+        poets_agent = Agent(
+            name="PoetsAgent",
+            instructions="You are PoetsAgent. You can use fileops tools (read_file, write_file, list_files, execute_shell_command) for any file or shell tasks.",
+            tools=[read_file_tool, write_file_tool, list_files_tool, execute_shell_command_tool],
+            mcp_servers=mcp_servers
+        )
+
+        # Randomly select starting agent
+        start_name = random.choice(agent_names)
+        starting_agent = agents[start_name]
+
+        logger.info(f"Poets agents created (using SQLite). Starting poet: {start_name}")
+        return starting_agent
+
+# Standard Python entry point
+if __name__ == "__main__":
+    import asyncio
+    import json
+    import os
+    import sys
+    print("\033[1;36m\n╔══════════════════════════════════════════════════════════════╗\n║   📰 POETS: SWARM MEDIA & RELEASE DEMO          ║\n╠══════════════════════════════════════════════════════════════╣\n║ This blueprint demonstrates viral doc propagation,           ║\n║ swarm-powered media release, and robust agent logic.         ║\n║ Try running: python blueprint_poets.py          ║\n╚══════════════════════════════════════════════════════════════╝\033[0m")
+    debug_env = os.environ.get("SWARM_DEBUG", "0")
+    debug_flag = "--debug" in sys.argv
+    def debug_print(msg):
+        if debug_env == "1" or debug_flag:
+            print(msg)
+    blueprint = PoetsBlueprint(blueprint_id="demo-1")
+    async def interact():
+        print("\nType your prompt (or 'exit' to quit):\n")
+        messages = []
+        handler = AsyncInputHandler()
+        while True:
+            print("You: ", end="", flush=True)
+            user_input = ""
+            warned = False
+            while True:
+                inp = handler.get_input(timeout=0.1)
+                if inp == 'warn' and not warned:
+                    print("\n[!] Press Enter again to interrupt and send a new message.", flush=True)
+                    warned = True
+                elif inp and inp != 'warn':
+                    user_input = inp
+                    break
+                await asyncio.sleep(0.05)
+            user_input = user_input.strip()
+            if user_input.lower() in {"exit", "quit", "q"}:
+                print("Goodbye!")
+                break
+            messages.append({"role": "user", "content": user_input})
+            spinner = PoetsSpinner()
+            spinner.start()
+            try:
+                all_results = []
+                async for response in blueprint.run(messages):
+                    # Assume response is a dict with 'messages' key
+                    for msg in response.get("messages", []):
+                        all_results.append(msg["content"])
+            finally:
+                spinner.stop()
+            display_operation_box(
+                op_type="Creative Output",
+                results=all_results,
+                params={"prompt": user_input},
+                result_type="creative"
+            )
+            # Optionally, clear messages for single-turn, or keep for context
+            messages = []
+    asyncio.run(interact())

swarm/core/slash_commands.py

@@ -31,11 +31,38 @@ def _compact_command(blueprint=None, args=None):
 # Built-in '/model' slash command
 @slash_registry.register('/model')
 def _model_command(blueprint=None, args=None):
-    """Show or switch the current LLM model."""
-    if args:
-        return f"[slash command] model switch not implemented. Requested: {args}"
-    profile = getattr(blueprint, 'llm_profile_name', None)
-    return f"[slash command] current LLM profile: {profile or 'unknown'}"
+    """
+    /model                   Show current default and overrides
+    /model <profile>         Set session default LLM profile
+    /model <agent> <profile> Override model profile for specific agent
+    """
+    # Sanity: blueprint must be provided
+    if blueprint is None:
+        return "No blueprint context available."
+    profiles = list(blueprint.config.get('llm', {}).keys())
+    # No args: list current settings
+    if not args:
+        lines = [f"Session default: {blueprint._session_model_profile}"]
+        for agent, prof in blueprint._agent_model_overrides.items():
+            lines.append(f"Agent {agent}: {prof}")
+        lines.append("Available profiles: " + ", ".join(profiles))
+        return lines
+    parts = args.split()
+    # Set session default
+    if len(parts) == 1:
+        prof = parts[0]
+        if prof not in profiles:
+            return f"Unknown profile '{prof}'. Available: {', '.join(profiles)}"
+        blueprint._session_model_profile = prof
+        return f"Session default LLM profile set to '{prof}'"
+    # Override specific agent
+    if len(parts) == 2:
+        agent_name, prof = parts
+        if prof not in profiles:
+            return f"Unknown profile '{prof}'. Available: {', '.join(profiles)}"
+        blueprint._agent_model_overrides[agent_name] = prof
+        return f"Model for agent '{agent_name}' overridden to '{prof}'"
+    return "Usage: /model [agent_name] <profile_name>"
 
 # Built-in '/approval' slash command
 @slash_registry.register('/approval')

swarm/extensions/cli/utils/async_input.py

@@ -0,0 +1,46 @@
+import threading
+import queue
+import sys
+import time
+
+class AsyncInputHandler:
+    """
+    Handles asynchronous CLI input during streaming output.
+    On first Enter: warns the user.
+    On second Enter: interrupts the operation and collects new input.
+    """
+    def __init__(self):
+        self.input_queue = queue.Queue()
+        self.interrupt_event = threading.Event()
+        self._warned = False
+        self._input_thread = threading.Thread(target=self._input_loop, daemon=True)
+        self._input_thread.start()
+
+    def _input_loop(self):
+        buffer = ''
+        while True:
+            c = sys.stdin.read(1)
+            if c == '\n':
+                if not self._warned:
+                    self.input_queue.put('warn')
+                    self._warned = True
+                else:
+                    self.input_queue.put(buffer)
+                    buffer = ''
+                    self.interrupt_event.set()
+                    self._warned = False
+            else:
+                buffer += c
+
+    def get_input(self, timeout=0.1):
+        try:
+            return self.input_queue.get(timeout=timeout)
+        except queue.Empty:
+            return None
+
+    def reset(self):
+        self.interrupt_event.clear()
+        self._warned = False
+
+    def interrupted(self):
+        return self.interrupt_event.is_set()

swarm/extensions/config/config_loader.py

@@ -11,18 +11,38 @@ DEFAULT_CONFIG_FILENAME = "swarm_config.json"
 # --- find_config_file, load_config, save_config, validate_config, get_profile_from_config, _substitute_env_vars_recursive ---
 # (Keep these functions as they were)
 def find_config_file( specific_path: Optional[str]=None, start_dir: Optional[Path]=None, default_dir: Optional[Path]=None,) -> Optional[Path]:
-    if specific_path: p=Path(specific_path); return p.resolve() if p.is_file() else logger.warning(f"Specified config path DNE: {specific_path}") or None # Fall through
+    # 1. XDG config path
+    xdg_config = Path(os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))) / "swarm" / DEFAULT_CONFIG_FILENAME
+    if xdg_config.is_file():
+        logger.debug(f"Found config XDG: {xdg_config}")
+        return xdg_config.resolve()
+    # 2. User-specified path
+    if specific_path:
+        p = Path(specific_path)
+        return p.resolve() if p.is_file() else logger.warning(f"Specified config path DNE: {specific_path}") or None # Fall through
+    # 3. Upwards from start_dir
     if start_dir:
-        current=start_dir.resolve()
+        current = start_dir.resolve()
         while current != current.parent:
-            if (cp := current / DEFAULT_CONFIG_FILENAME).is_file(): logger.debug(f"Found config upwards: {cp}"); return cp.resolve()
+            if (cp := current / DEFAULT_CONFIG_FILENAME).is_file():
+                logger.debug(f"Found config upwards: {cp}")
+                return cp.resolve()
             current = current.parent
-        if (cp := current / DEFAULT_CONFIG_FILENAME).is_file(): logger.debug(f"Found config at root: {cp}"); return cp.resolve()
-    if default_dir and (cp := default_dir.resolve() / DEFAULT_CONFIG_FILENAME).is_file(): logger.debug(f"Found config default: {cp}"); return cp.resolve()
-    cwd=Path.cwd();
+        if (cp := current / DEFAULT_CONFIG_FILENAME).is_file():
+            logger.debug(f"Found config at root: {cp}")
+            return cp.resolve()
+    # 4. Default dir
+    if default_dir and (cp := default_dir.resolve() / DEFAULT_CONFIG_FILENAME).is_file():
+        logger.debug(f"Found config default: {cp}")
+        return cp.resolve()
+    # 5. CWD
+    cwd = Path.cwd()
     if start_dir is None or cwd != start_dir.resolve():
-        if (cp := cwd / DEFAULT_CONFIG_FILENAME).is_file(): logger.debug(f"Found config cwd: {cp}"); return cp.resolve()
-    logger.debug(f"Config '{DEFAULT_CONFIG_FILENAME}' not found."); return None
+        if (cp := cwd / DEFAULT_CONFIG_FILENAME).is_file():
+            logger.debug(f"Found config cwd: {cp}")
+            return cp.resolve()
+    logger.debug(f"Config '{DEFAULT_CONFIG_FILENAME}' not found.")
+    return None
 
 def load_config(config_path: Path) -> Dict[str, Any]:
     logger.debug(f"Loading config from {config_path}")

swarm/settings.py

@@ -90,9 +90,9 @@ ASGI_APPLICATION = 'swarm.asgi.application'
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3',
-        'NAME': BASE_DIR.parent / 'db.sqlite3',
+        'NAME': os.environ.get('DJANGO_DB_NAME', '/tmp/db.sqlite3'),
         'TEST': {
-            'NAME': BASE_DIR.parent / 'test_db.sqlite3',
+            'NAME': os.environ.get('DJANGO_TEST_DB_NAME', '/tmp/test_db.sqlite3'),
             'OPTIONS': {
                 'timeout': 20,
                 'init_command': "PRAGMA journal_mode=WAL;",