devhive 0.1.18__tar.gz → 0.1.20__tar.gz

{devhive-0.1.18 → devhive-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devhive
-Version: 0.1.18
+Version: 0.1.20
 Summary: DevHive MCP Server
 Requires-Python: >=3.10
 License-File: LICENSE

devhive-0.1.20/devhive/agents/ceo.py

@@ -0,0 +1,95 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from devhive.agents.base_agent import BaseAgent
+from devhive.core.project_state_manager import ProjectStateManager
+
+class CEOAgent(BaseAgent):
+    role = "CEO"
+    
+    def get_next_agent_deterministic(self) -> Dict[str, Any]:
+        """
+        Determine next agent to run based on dynamic workflow_plan from the state.
+        
+        Returns:
+            Dict with 'agent' (role name) and 'reason' (explanation)
+        """
+        state = self.state_manager.get_state()
+        artifacts = state.get("artifacts", {})
+        
+        # If the CEO hasn't planned the workflow yet, run the CEO.
+        if artifacts.get("workflow_plan") is None:
+            return {
+                "agent": "CEO",
+                "reason": "Need initial workflow planning based on requirements"
+            }
+            
+        # Get the workflow plan created by the CEO
+        try:
+            plan_id = artifacts.get("workflow_plan")
+            plan_data = self.artifact_manager.load_artifact(plan_id)
+            workflow_plan = plan_data.get("workflow_plan", [])
+            # Fallback if workflow_plan is malformed
+            if not workflow_plan:
+                workflow_plan = ["Explorer", "Developer", "QA", "Archivist"]
+        except Exception:
+            # Fallback if something is broken
+            workflow_plan = ["Explorer", "Developer", "QA", "Archivist"]
+            
+        # Map agent names to artifact keys
+        mapping = {
+            "Explorer": "exploration",
+            "Proposal": "proposal",
+            "Architect": "architecture",
+            "TaskPlanner": "tasks",
+            "Developer": "implementation",
+            "QA": "tests",
+            "Auditor": "verification",
+            "Archivist": "archive"
+        }
+        
+        # Iterate over the plan and find the first incomplete agent
+        for agent in workflow_plan:
+            artifact_key = mapping.get(agent)
+            
+            if artifact_key == "implementation":
+                # Special iterative Developer logic
+                if artifacts.get("implementation") is None:
+                    dev_progress = state.get("developer_progress", {})
+                    pending_tasks = dev_progress.get("pending_tasks", [])
+                    completed_tasks = dev_progress.get("completed_tasks", [])
+                    
+                    if not dev_progress or pending_tasks:
+                        task_count = len(pending_tasks) if pending_tasks else "tasks"
+                        return {
+                            "agent": "Developer",
+                            "reason": f"Need to execute {task_count} pending tasks sequentially"
+                        }
+                    elif not pending_tasks and completed_tasks:
+                        # Implementation is complete based on tasks
+                        continue
+                    else:
+                        return {
+                            "agent": "Developer",
+                            "reason": "Ready for implementation"
+                        }
+                continue
+                
+            if artifacts.get(artifact_key) is None:
+                return {
+                    "agent": agent,
+                    "reason": f"Next agent in workflow plan: {agent}"
+                }
+        
+        # All done
+        return {
+            "agent": "Complete",
+            "reason": "All pipeline stages in the workflow plan have finished, project is complete"
+        }
+    
+    async def execute(self, ctx: Context, **kwargs) -> Dict[str, Any]:
+        """
+        CEO Agent execution logic is handled by TaskOrchestrator in the new task-based workflow.
+        This legacy method is not used.
+        """
+        pass

{devhive-0.1.18 → devhive-0.1.20}/devhive/cli.py

@@ -5,55 +5,55 @@ import json
 import os
 from pathlib import Path
 
-# Try to find default agent file location relative to package
-# This assumes the package structure allows finding the file in the root
+# Try to find default skill file location relative to package
 PACKAGE_ROOT = Path(__file__).parent.parent
-DEFAULT_AGENT_PATH = PACKAGE_ROOT / "DEVHIVE_AGENT.md"
+DEFAULT_SKILL_PATH = PACKAGE_ROOT / "skills" / "devhive_workflow.md"
 
-def get_default_agent_content():
-    """Reads the DEVHIVE_AGENT.md content from the package source."""
-    if DEFAULT_AGENT_PATH.exists():
-        return DEFAULT_AGENT_PATH.read_text()
+def get_default_skill_content():
+    """Reads the devhive_workflow.md content from the package source."""
+    if DEFAULT_SKILL_PATH.exists():
+        return DEFAULT_SKILL_PATH.read_text()
     
-    # Fallback content if file is totally missing (should not happen in proper install)
-    return """# DevHive Agent System Prompt
+    # Fallback content if file is missing
+    return """# DevHive Workflow Orchestrator
 
-You are the DevHive Agent, an autonomous software development orchestrator.
-Your goal is to manage the full software development lifecycle using the DevHive MCP server tools.
+This skill defines the autonomous execution loop for the DevHive AI software development pipeline.
 
-## Core Workflow
+## Core Rules
+1. **Autonomous Execution**: Run the entire DevHive pipeline autonomously. Do not stop to ask the user for permission between each agent step unless an unrecoverable error occurs or the Explorer agent explicitly asks a `clarification_question`.
+2. **Subagent Delegation**: You MUST use the `Task` tool with `subagent_type="general"` to execute the prompts generated by the MCP server. Do not execute the prompts yourself in the main context.
+3. **Strict JSON**: The DevHive MCP server expects strict JSON. Instruct the subagent to output ONLY valid JSON without markdown formatting.
 
-1.  **Start/Resume Project**:
-    - Use `devhive_start_pipeline(project_name, requirements)` to initialize a project or get the next task.
-    - If the project already exists, this will resume from the last state.
+## The Execution Loop
 
-2.  **Execute Task**:
-    - The output of `devhive_start_pipeline` (or `devhive_submit_result`) provides a `next_task` object containing:
-        - `agent`: The sub-agent role (e.g., Explorer, Developer).
-        - `system_prompt`: The specific instructions for this sub-agent.
-        - `user_prompt`: The context and requirements for the task.
-    - You must execute this task. 
-      - **OpenCode**: Use the `Task` tool with the provided prompts.
-      - **Copilot**: Act as the sub-agent directly using the prompts.
+When a user asks you to build a feature or start a project using DevHive, follow this exact procedure:
 
-3.  **Submit Result**:
-    - Once the sub-agent task is complete, use `devhive_submit_result(project_name, agent_name, llm_response)` to save the work.
-    - This tool will return the *next* task in the pipeline.
-    - Repeat step 2 with the new task.
+### 1. Initialization
+Use the `devhive_start_pipeline` tool.
+- `project_name`: A short snake_case identifier derived from the request.
+- `requirements`: The user's full request.
 
-## Available Tools
+The tool will return a JSON envelope containing `status`, `agent`, `system_prompt`, `user_prompt`, `expected_keys`, and `task_description`.
 
-- `devhive_start_pipeline`: Initialize project and get first task.
-- `devhive_submit_result`: Save task result and get next task.
-- `devhive_search_memory`: Retrieve context from previous steps.
-- `devhive_get_memory_stats`: Check project memory usage.
-- `devhive_get_recent_memories`: See recent project activity.
+### 2. Main Loop
+While `status` is `"pending"`:
 
-## Important Instructions
+**A. Launch Subagent**
+Use the `Task` tool with `subagent_type="general"`.
+- `description`: The `task_description` from the envelope.
+- `prompt`: Combine the `system_prompt` and `user_prompt` from the envelope. Append this CRITICAL instruction: *"You must ONLY output valid JSON containing these exact keys: {expected_keys}. Do not include any other text, markdown formatting, or explanations."*
 
-- Always follow the strict sequential pipeline: Explorer -> Proposal -> Architect -> TaskPlanner -> Developer -> QA -> Auditor -> Archivist.
-- Do not skip steps unless the pipeline explicitly skips them.
-- Use the prompts provided by the tools exactly as given.
+**B. Submit Result**
+Once the subagent returns its JSON output, use the `devhive_submit_result` tool.
+- `project_name`: The current project name.
+- `agent_name`: The `agent` from the current envelope.
+- `llm_response`: The raw JSON output from the subagent.
+
+**C. Process Server Response**
+The tool will return a new envelope:
+- If `status` == `"success"`: Print a brief update to the user. If `next_task` is present, update your envelope and repeat the loop.
+- If `status` == `"error"`: The envelope has an error message. Launch the subagent again, provide the error and the previous output, and ask it to fix the JSON structure. Retry up to 3 times.
+- If `status` == `"complete"`: The pipeline is finished. Give the user a final summary and exit the loop.
 """
 
 def configure():
@@ -68,24 +68,24 @@ def configure():
         print("Invalid choice. Please type 'opencode', 'copilot', or 'both'.")
 
     # 2. Locate source file
-    cwd_agent = Path("DEVHIVE_AGENT.md").resolve()
-    pkg_agent = DEFAULT_AGENT_PATH.resolve()
+    cwd_skill = Path("skills/devhive_workflow.md").resolve()
+    pkg_skill = DEFAULT_SKILL_PATH.resolve()
     
     source_to_use = None
     
-    if cwd_agent.exists():
-        print(f"[+] Found agent file in current directory: {cwd_agent}")
-        source_to_use = cwd_agent
-    elif pkg_agent.exists():
-        print(f"[+] Found agent file in package: {pkg_agent}")
-        source_to_use = pkg_agent
+    if cwd_skill.exists():
+        print(f"[+] Found skill file in current directory: {cwd_skill}")
+        source_to_use = cwd_skill
+    elif pkg_skill.exists():
+        print(f"[+] Found skill file in package: {pkg_skill}")
+        source_to_use = pkg_skill
     else:
-        print("[-] DEVHIVE_AGENT.md not found.")
-        print("[*] Using embedded default agent prompt.")
-        temp_path = Path("DEVHIVE_AGENT.md").resolve()
+        print("[-] skills/devhive_workflow.md not found.")
+        print("[*] Using embedded default skill prompt.")
+        temp_path = Path("devhive_workflow.md").resolve()
         try:
             with open(temp_path, "w") as f:
-                f.write(get_default_agent_content())
+                f.write(get_default_skill_content())
             print(f"[+] Created temporary source file at: {temp_path}")
             source_to_use = temp_path
         except Exception as e:
@@ -94,16 +94,36 @@ def configure():
 
     # 3. Configure OpenCode
     if choice in ["opencode", "both"]:
-        dest_dir = Path.home() / ".config" / "opencode" / "agents"
-        dest_file = dest_dir / "DevHive0118.md"
-        _copy_agent_file(source_to_use, dest_dir, dest_file, "OpenCode Agent")
+        # Remove legacy agent
+        old_agent_dir = Path.home() / ".config" / "opencode" / "agents"
+        old_agent = old_agent_dir / "DevHive0119.md"
+        if old_agent.exists():
+            print(f"[*] Removing legacy OpenCode agent: {old_agent}")
+            try:
+                old_agent.unlink()
+            except Exception as e:
+                print(f"[-] Could not remove legacy agent: {e}")
+        
+        dest_dir = Path.home() / ".config" / "opencode" / "skills"
+        dest_file = dest_dir / "devhive_workflow.md"
+        _copy_agent_file(source_to_use, dest_dir, dest_file, "OpenCode Skill")
         _configure_devhive()
 
     # 4. Configure Copilot
     if choice in ["copilot", "both"]:
-        dest_dir = Path.home() / ".copilot" / "agents"
-        dest_file = dest_dir / "DevHive.md"
-        _copy_agent_file(source_to_use, dest_dir, dest_file, "Copilot Agent")
+        # Remove legacy agent
+        old_agent_dir = Path.home() / ".copilot" / "agents"
+        old_agent = old_agent_dir / "DevHive.md"
+        if old_agent.exists():
+            print(f"[*] Removing legacy Copilot agent: {old_agent}")
+            try:
+                old_agent.unlink()
+            except Exception as e:
+                print(f"[-] Could not remove legacy agent: {e}")
+
+        dest_dir = Path.home() / ".copilot" / "instructions"
+        dest_file = dest_dir / "devhive_workflow.md"
+        _copy_agent_file(source_to_use, dest_dir, dest_file, "Copilot Instructions")
         _configure_vscode_copilot(dest_file)
 
     print("\nConfiguration complete!")

{devhive-0.1.18 → devhive-0.1.20}/devhive/core/prompt_builder.py

@@ -27,7 +27,9 @@ Note: You have access to the devhive_search_memory tool if you need to find spec
             Dictionary with 'system_prompt' and 'user_prompt' keys
         """
         
-        if agent_role == "Explorer":
+        if agent_role == "CEO":
+            return PromptBuilder._build_ceo_prompts(context, **kwargs)
+        elif agent_role == "Explorer":
             return PromptBuilder._build_explorer_prompts(context, **kwargs)
         elif agent_role == "Proposal":
             return PromptBuilder._build_proposal_prompts(context)
@@ -47,43 +49,155 @@ Note: You have access to the devhive_search_memory tool if you need to find spec
             raise ValueError(f"Unknown agent role: {agent_role}")
 
     @staticmethod
-    def _build_explorer_prompts(context: Dict[str, Any], **kwargs) -> Dict[str, str]:
+    def _build_ceo_prompts(context: Dict[str, Any], **kwargs) -> Dict[str, str]:
         requirements = kwargs.get("requirements", "No requirements provided")
         
-        system_prompt = "You are the Analyst (Explorer). Output JSON only."
+        system_prompt = """
+You are an AI orchestration agent called "CEO".
+
+Your job is to orchestrate an AI software development pipeline by selecting and ordering agents to fulfill a feature request.
+
+Available agents:
+- Explorer
+- Proposal
+- Architect
+- TaskPlanner
+- Developer
+- QA
+- Auditor
+- Archivist
+
+Agent roles:
+
+Explorer
+Analyzes requirements, constraints and dependencies.
+
+Proposal
+Creates a structured feature proposal and acceptance criteria.
+
+Architect
+Designs technical architecture and system structure.
+
+TaskPlanner
+Breaks the feature into development tasks.
+
+Developer
+Implements the feature.
+
+QA
+Creates tests for the implementation.
+
+Auditor
+Reviews architecture, consistency, and security.
+
+Archivist
+Archives the final project state.
+
+Pipeline rules:
+- Explorer should normally run first
+- Developer must run before Archivist
+- Archivist must always be the final step
+- Agents must appear only once
+- The workflow must be logically ordered
+
+Agent selection guidelines:
+
+Proposal
+Use when the feature requires product clarification or acceptance criteria.
+
+Architect
+Use when backend systems, APIs, or architecture are involved.
+
+TaskPlanner
+Use when the implementation requires multiple tasks or moderate complexity.
+
+QA
+Use when code with logic is implemented.
+
+Auditor
+Use when architecture or security should be reviewed.
+
+Simple features may skip Proposal, Architect, TaskPlanner, QA, and Auditor.
+
+Output rules:
+- Return valid JSON only
+- Do not include explanations outside the JSON
+- Follow the schema exactly
+
+Schema:
+{
+  "workflow_plan": string[],
+  "reasoning": string
+}
+"""
         
-        user_prompt = f"""Analyze the following feature request: {requirements}
+        user_prompt = f"""
+Feature request:
 
-Context: {json.dumps(context, default=str)}
+{requirements}
 
-Your task is to perform initial analysis and exploration.
-Check 'project_guidelines' in the context. 
-- If it says "Guidelines not found.", you MUST establish the technology stack.
-  - If the stack is clear from the request (e.g. "Use Python/Flask"), generate a Markdown string for 'new_guidelines_content'.
-  - If the stack is unclear, providing a question in 'clarification_question'.
+Determine the optimal sequence of agents to execute.
+"""
+        
+        return {
+            "system_prompt": system_prompt,
+            "user_prompt": user_prompt
+        }
 
-Return JSON with the following keys:
-- user_needs: String describing what users need from this feature
-- constraints: List of technical or business constraints
-- dependencies: List of external dependencies or requirements
-- risks: List of potential risks or challenges
-- complexity: "low", "medium", or "high". 
-  - "low": Simple changes, no architecture needed.
-  - "medium": Moderate changes, needs proposal but no complex architecture.
-  - "high": Complex changes, needs full architecture and planning.
-- suggested_workflow: "fast_track" (low), "standard" (medium), or "comprehensive" (high)
-- new_guidelines_content: (Optional) Markdown string with best practices if guidelines were missing.
-- clarification_question: (Optional) Question to ask user if tech stack is unclear.
+    @staticmethod
+    def _build_explorer_prompts(context: Dict[str, Any], **kwargs) -> Dict[str, str]:
+        requirements = kwargs.get("requirements", "No requirements provided")
+        
+        system_prompt = """
+You are an AI software architecture analyst called "Analyst (Explorer)".
+
+Your role is to analyze feature requests and produce structured technical analysis for downstream agents.
+
+Responsibilities:
+- Identify user needs
+- Detect constraints
+- List dependencies
+- Identify risks
+- Estimate complexity
+- Suggest workflow
+
+Context may include project information such as technology guidelines.
+
+Guidelines handling:
+- If project_guidelines says "Guidelines not found.", determine the likely technology stack.
+- If the stack is clear, generate new guidelines.
+- If the stack is unclear, ask a clarification question.
+
+Complexity levels:
+- low: simple changes, minimal architecture
+- medium: moderate implementation work
+- high: architectural changes or major system impact
+
+Output rules:
+- Output valid JSON only
+- Do not include explanations outside JSON
+- Follow the schema strictly
+
+Schema:
+{
+  "user_needs": string,
+  "constraints": string[],
+  "dependencies": string[],
+  "risks": string[],
+  "complexity": "low" | "medium" | "high",
+  "suggested_workflow": "fast_track" | "standard" | "comprehensive",
+  "new_guidelines_content": string | null,
+  "clarification_question": string | null
+}
+"""
+        
+        user_prompt = f"""
+Analyze the following feature request: {requirements}
 
-Example format:
-{{
-  "user_needs": "Users need to export data in CSV format for analysis",
-  "constraints": ["Must work with existing authentication", "Limited to 10MB file size"],
-  "dependencies": ["CSV library", "File storage system"],
-  "risks": ["Large datasets may cause performance issues", "Security concerns with file downloads"],
-  "complexity": "medium",
-  "suggested_workflow": "standard"
-}}"""
+Context: {json.dumps(context, default=str)}
+
+Perform the analysis and exploration and return the JSON response.
+"""
         
         return {
             "system_prompt": system_prompt,

{devhive-0.1.18 → devhive-0.1.20}/devhive/core/task_orchestrator.py

@@ -1,6 +1,6 @@
 """
 Task-based pipeline orchestrator.
-Manages agent sequence and returns Task launch instructions for OpenCode.
+Manages agent sequence and returns Task launch instructions for SDD Skill execution.
 """
 
 import json
@@ -27,7 +27,7 @@ class TaskOrchestrator:
     - Builds prompts using PromptBuilder
     - Validates responses using ResponseValidator
     - Saves artifacts using ArtifactManager
-    - Returns structured envelopes for OpenCode
+    - Returns structured envelopes for Skill execution
     """
     
     def __init__(self, project_name: str):
@@ -279,6 +279,7 @@ class TaskOrchestrator:
     def _validate_response(self, agent_name: str, response: Dict[str, Any]) -> tuple[bool, str]:
         """Validate response using appropriate validator method."""
         validators = {
+            "CEO": ResponseValidator.validate_ceo,
             "Explorer": ResponseValidator.validate_explorer,
             "Proposal": ResponseValidator.validate_proposal,
             "Architect": ResponseValidator.validate_architect,
@@ -303,6 +304,7 @@ class TaskOrchestrator:
     def _get_artifact_key(self, agent_name: str) -> str:
         """Map agent name to artifact key used in state."""
         mapping = {
+            "CEO": "workflow_plan",
             "Explorer": "exploration",
             "Proposal": "proposal",
             "Architect": "architecture",
@@ -313,7 +315,7 @@ class TaskOrchestrator:
             "Archivist": "archive"
         }
         return mapping.get(agent_name, agent_name.lower())
-    
+
     def _generate_summary(self, agent_name: str, data: Dict[str, Any]) -> str:
         """
         Generate 1-3 sentence executive summary of agent's work.
@@ -322,6 +324,7 @@ class TaskOrchestrator:
         via their generate_summary() method for more specific summaries.
         """
         summaries = {
+            "CEO": self._summarize_ceo,
             "Explorer": self._summarize_explorer,
             "Proposal": self._summarize_proposal,
             "Architect": self._summarize_architect,
@@ -334,7 +337,12 @@ class TaskOrchestrator:
         
         summarizer = summaries.get(agent_name, lambda x: f"{agent_name} completed successfully.")
         return summarizer(data)
-    
+
+    def _summarize_ceo(self, data: Dict[str, Any]) -> str:
+        """Generate summary for CEO agent."""
+        plan = data.get("workflow_plan", [])
+        return f"Planned workflow with {len(plan)} agents: {' -> '.join(plan)}."
+
     def _summarize_explorer(self, data: Dict[str, Any]) -> str:
         """Generate summary for Explorer agent."""
         constraints_count = len(data.get("constraints", []))

{devhive-0.1.18 → devhive-0.1.20}/devhive/server.py

@@ -55,7 +55,7 @@ def _parse_json_response(text: str) -> Dict[str, Any]:
         raise ValueError(f"Invalid JSON response: {e}")
 
 # ============================================================================
-# TASK-BASED WORKFLOW TOOLS (Recommended - Uses OpenCode Task Tool)
+# TASK-BASED WORKFLOW TOOLS (Recommended - Use devhive_workflow skill)
 # ============================================================================
 
 @mcp.tool()
@@ -64,7 +64,7 @@ def devhive_start_pipeline(project_name: str, requirements: str) -> str:
     Start a new DevHive pipeline with Task-based execution.
     
     This is the RECOMMENDED way to use DevHive. It returns Task launch instructions
-    that OpenCode can use to execute each agent in isolated context.
+    that OpenCode should execute using the devhive_workflow skill.
 
     Remember always read AGENTS.md if exists.
     
@@ -75,7 +75,7 @@ def devhive_start_pipeline(project_name: str, requirements: str) -> str:
     Returns:
         JSON with Task launch instructions:
         - status: "pending" (next task ready) or "complete" (pipeline done)
-        - agent: Next agent to run (Explorer, Proposal, etc.)
+        - agent: Next agent to run (CEO, Explorer, Proposal, etc.)
         - reason: Why this agent needs to run
         - system_prompt: System prompt for the Task
         - user_prompt: User prompt for the Task
@@ -85,7 +85,7 @@ def devhive_start_pipeline(project_name: str, requirements: str) -> str:
     
     Example:
         result = devhive_start_pipeline("csv_export", "Add CSV export to dashboard")
-        # Use result["system_prompt"] and result["user_prompt"] with OpenCode Task tool
+        # Use result["system_prompt"] and result["user_prompt"] with Task tool (general)
         # Then call devhive_submit_result() with the Task output
     """
     try:
@@ -94,7 +94,7 @@ def devhive_start_pipeline(project_name: str, requirements: str) -> str:
         # Initialize orchestrator (creates project if needed)
         orchestrator = TaskOrchestrator(project_name)
         
-        # Get first task (Explorer)
+        # Get first task (CEO)
         task_info = orchestrator.get_next_task(requirements=requirements)
         
         return json.dumps(task_info, indent=2)
@@ -116,7 +116,7 @@ def devhive_submit_result(project_name: str, agent_name: str, llm_response: str)
     
     Args:
         project_name: Project identifier
-        agent_name: Name of agent that produced result (Explorer, Proposal, Architect,
+        agent_name: Name of agent that produced result (CEO, Explorer, Proposal, Architect,
                    TaskPlanner, Developer, QA, Auditor, or Archivist)
         llm_response: Raw LLM response (JSON string, can include markdown code blocks)
     
@@ -136,7 +136,7 @@ def devhive_submit_result(project_name: str, agent_name: str, llm_response: str)
         if result["status"] == "success":
             print(result["executive_summary"])
             next_task = result["next_task"]
-            # Use next_task with OpenCode Task tool
+            # Use next_task with Task tool (general)
     """
     try:
         from devhive.core.task_orchestrator import TaskOrchestrator
@@ -182,7 +182,7 @@ def get_next_step(project_name: str) -> str:
     
     Returns:
         JSON string with:
-        - agent: The agent role name (Explorer, Proposal, etc.)
+        - agent: The agent role name (CEO, Explorer, Proposal, etc.)
         - reason: Why this agent needs to run
         - system_prompt: System prompt to send to LLM
         - user_prompt: User prompt to send to LLM  
@@ -211,9 +211,9 @@ def get_next_step(project_name: str) -> str:
         context = agent.get_context()
         
         # Build prompts using PromptBuilder
-        # For Explorer, we need to check if requirements are in kwargs
-        if agent_role == "Explorer":
-            # Requirements should be provided when executing Explorer
+        # For Explorer/CEO, we need to check if requirements are in kwargs
+        if agent_role in ["Explorer", "CEO"]:
+            # Requirements should be provided when executing
             prompts = PromptBuilder.build_prompts(agent_role, context, requirements="[Requirements will be provided when executing]")
         else:
             prompts = PromptBuilder.build_prompts(agent_role, context)

{devhive-0.1.18 → devhive-0.1.20}/devhive/utils/validation.py

@@ -7,6 +7,28 @@ class ResponseValidator:
     Ensures responses contain required keys and valid data structures.
     """
 
+    @staticmethod
+    def validate_ceo(response: Dict[str, Any]) -> Tuple[bool, str]:
+        """
+        Validate CEO agent response.
+        
+        Expected keys: workflow_plan, reasoning
+        """
+        required_keys = ["workflow_plan", "reasoning"]
+        is_valid, error = ResponseValidator._validate_keys(response, required_keys, "CEO")
+        if not is_valid:
+            return is_valid, error
+            
+        if not isinstance(response.get("workflow_plan"), list):
+            return False, "CEO: 'workflow_plan' must be a list of agent names"
+            
+        valid_agents = ["Explorer", "Proposal", "Architect", "TaskPlanner", "Developer", "QA", "Auditor", "Archivist"]
+        for agent in response["workflow_plan"]:
+            if agent not in valid_agents:
+                return False, f"CEO: Invalid agent name '{agent}' in workflow_plan. Valid agents are: {', '.join(valid_agents)}"
+                
+        return True, ""
+
     @staticmethod
     def validate_explorer(response: Dict[str, Any]) -> Tuple[bool, str]:
         """
@@ -191,6 +213,7 @@ class ResponseValidator:
             List of expected key names
         """
         key_mapping = {
+            "CEO": ["workflow_plan", "reasoning"],
             "Explorer": ["user_needs", "constraints", "dependencies", "risks", "complexity", "suggested_workflow", "new_guidelines_content", "clarification_question"],
             "Proposal": ["feature_description", "user_value", "acceptance_criteria", "scope"],
             "Architect": ["architecture_pattern", "components", "data_models", "apis"],

{devhive-0.1.18 → devhive-0.1.20}/devhive.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devhive
-Version: 0.1.18
+Version: 0.1.20
 Summary: DevHive MCP Server
 Requires-Python: >=3.10
 License-File: LICENSE

{devhive-0.1.18 → devhive-0.1.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devhive"
-version = "0.1.18"
+version = "0.1.20"
 description = "DevHive MCP Server"
 requires-python = ">=3.10"
 

{devhive-0.1.18 → devhive-0.1.20}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="devhive",
-    version="0.1.18",
+    version="0.1.20",
     packages=find_packages(),
     package_data={
         "devhive": ["skills/*.md", "skills/*/*.md"],

devhive-0.1.18/devhive/agents/ceo.py

@@ -1,190 +0,0 @@
-import json
-from typing import Dict, Any
-from mcp.server.fastmcp import Context
-from devhive.agents.base_agent import BaseAgent
-from devhive.core.project_state_manager import ProjectStateManager
-
-class CEOAgent(BaseAgent):
-    role = "CEO"
-    
-    def get_next_agent_deterministic(self) -> Dict[str, Any]:
-        """
-        Determine next agent to run based on current state (no LLM needed).
-        This is a rule-based decision making process following the strict pipeline sequence.
-        
-        Pipeline order:
-        1. Explorer
-        2. Proposal
-        3. Architect
-        4. TaskPlanner
-        5. Developer (Iterative)
-        6. QA
-        7. Auditor
-        8. Archivist
-        
-        Returns:
-            Dict with 'agent' (role name) and 'reason' (explanation)
-        """
-        state = self.state_manager.get_state()
-        artifacts = state.get("artifacts", {})
-        
-        # Check each stage in order
-        if artifacts.get("exploration") is None:
-            return {
-                "agent": "Explorer",
-                "reason": "Need initial feature analysis and exploration"
-            }
-            
-        # Determine complexity from exploration artifact
-        complexity = "high" # Default to high safety
-        try:
-            expl_id = artifacts.get("exploration")
-            if expl_id:
-                expl_data = self.artifact_manager.load_artifact(expl_id)
-                complexity = expl_data.get("complexity", "high").lower()
-        except Exception:
-            pass # Fallback to high complexity on error
-        
-        # Dynamic Routing based on Complexity
-        # Low: Explorer -> Developer -> QA -> Archivist
-        # Medium: Explorer -> Proposal -> Developer -> QA -> Archivist
-        # High: Full Suite
-        
-        if artifacts.get("proposal") is None:
-            if complexity == "low":
-                pass # Skip Proposal
-            else:
-                return {
-                    "agent": "Proposal",
-                    "reason": "Exploration complete, need feature proposal"
-                }
-        
-        if artifacts.get("architecture") is None:
-            if complexity in ["low", "medium"]:
-                pass # Skip Architecture
-            else:
-                return {
-                    "agent": "Architect",
-                    "reason": "Proposal complete, need technical architecture design"
-                }
-        
-        if artifacts.get("tasks") is None:
-            if complexity in ["low", "medium"]:
-                pass # Skip Task Planning
-            else:
-                return {
-                    "agent": "TaskPlanner",
-                    "reason": "Architecture complete, need task breakdown"
-                }
-        
-        if artifacts.get("implementation") is None:
-            # Iterative Developer Workflow
-            dev_progress = state.get("developer_progress", {})
-            pending_tasks = dev_progress.get("pending_tasks", [])
-            completed_tasks = dev_progress.get("completed_tasks", [])
-            
-            # If we haven't initialized developer progress yet, we need to route to developer
-            # Or if there are still pending tasks to complete
-            if not dev_progress or pending_tasks:
-                task_count = len(pending_tasks) if pending_tasks else "tasks"
-                return {
-                    "agent": "Developer",
-                    "reason": f"Need to execute {task_count} pending tasks sequentially"
-                }
-            elif not pending_tasks and completed_tasks:
-                # This state shouldn't normally happen (orchestrator should create implementation artifact)
-                # But just in case, if pending is empty but completed is not, we're done with implementation
-                pass
-            else:
-                # No tasks found at all? Fallback to single run
-                return {
-                    "agent": "Developer",
-                    "reason": "Ready for implementation"
-                }
-        
-        if artifacts.get("tests") is None:
-            return {
-                "agent": "QA",
-                "reason": "Implementation complete, need tests"
-            }
-        
-        if artifacts.get("verification") is None:
-            if complexity in ["low", "medium"]:
-                pass # Skip Auditor
-            else:
-                return {
-                    "agent": "Auditor",
-                    "reason": "Tests complete, need final verification"
-                }
-        
-        if artifacts.get("archive") is None:
-            return {
-                "agent": "Archivist",
-                "reason": "All stages complete, ready to archive project"
-            }
-        
-        # All done
-        return {
-            "agent": "Complete",
-            "reason": "All pipeline stages finished, project is complete"
-        }
-    
-    async def execute(self, ctx: Context, **kwargs) -> Dict[str, Any]:
-        """
-        Original LLM-based decision making (requires sampling support).
-        Currently not used in manual workflow.
-        """
-        state_manager = ProjectStateManager(self.project_name)
-        state = state_manager.get_state()
-
-        context = {
-            "project_status": state.get('status'),
-            "artifacts_summary": state.get("artifacts", {})
-        }
-
-        sys_prompt = """
-        You are the CEO orchestrating an AI software development pipeline.
-
-        The pipeline is strictly sequential:
-
-        1 Explorer
-        2 Proposal
-        3 Architect
-        4 TaskPlanner
-        5 Developer
-        6 QA
-        7 Auditor
-        8 Archivist
-
-        Rules:
-
-        - NEVER return Wait unless the pipeline is finished
-        - ALWAYS select the next missing role
-        - Each role produces an artifact
-
-        Explorer → exploration
-        Proposal → proposal
-        Architect → architecture
-        TaskPlanner → tasks
-        Developer → implementation
-        QA → tests
-        Auditor → verification
-        Archivist → archived
-
-        Return JSON only:
-        { "decision": "Run <Role>", "reason": "..." }
-        """
-        user_prompt = f"""Decide next step.
-
-Project: {context.get('project_name')}
-Status: {context.get('project_status')}
-Stage: {context.get('stage')}
-Artifacts: {json.dumps(context.get('artifacts_summary', {}), indent=2)}
-
-Available Roles: Explorer, Proposal, Architect, TaskPlanner, Developer, QA, Auditor, Archivist.
-Return JSON: {{ "decision": "Run <Role>", "reason": "..." }}
-If finished, "Run Archivist".
-If stage is "initialization", "Run Explorer"
-"""
-        resp = await self._call_llm(ctx, sys_prompt, user_prompt)
-        return self._parse_json(resp)