@oswaldzsh/devhive 0.1.2 → 0.1.4

package/control_plane/cli.py

@@ -3,29 +3,19 @@
 dh — DevHive CLI
 
 Usage:
-  dh                      Start interactive REPL with live dashboard
-  dh do <description>     Submit a task, auto-parse into TaskSpec
-  dh do -f <file>         Submit a task from JSON/YAML spec file
-  dh run                  Start orchestrator daemon
+  dh                      Start interactive REPL
+  dh do <description>     Submit a task
   dh status               Show system status
-  dh log <task-id>        Show task execution timeline
-  dh review               Interactive escalation review
-  dh resolve <id>         Resolve an escalation
-  dh !<shell command>      Escape to shell (from interactive mode)
-
-Examples:
-  dh do "fix the login timeout bug in auth/session.py"
-  dh do "add rate limiting middleware to all API endpoints" -p HIGH
-  dh do -f task_spec.yaml
-  dh status
-  dh log task-20260624-143000-abc123
-  dh review
+  dh log <task-id>        Show task timeline
+  dh review               Review escalations
+  dh resolve <id>         Resolve escalation
 """
 
 import argparse
 import asyncio
 import json
 import os
+import re
 import shlex
 import subprocess
 import sys
@@ -33,555 +23,313 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
-# Rich imports
 from rich.console import Console
-from rich.live import Live
 from rich.panel import Panel
 from rich.text import Text
 from rich.table import Table
 from rich import box
 
-# DevHive imports
 from protocol.schemas import TaskSpec, Priority
 from orchestrator.engine import Orchestrator
-from control_plane.tui import (
-    DevHiveTUI, status_display, task_timeline, escalation_review,
-)
-
-
-VERSION = "0.1.0"
-BANNER = r"""
-  ╔══════════════════════════════════════════╗
-  ║   ____             __  __  _             ║
-  ║  / __ \ ___ __   __/ / / / (_)   _____   ║
-  ║ / / / // _ \\ \ / / /_/ / / / | / / _ \  ║
-  ║/ /_/ /|  __/\ V / __  / / /| |/ /  __/  ║
-  ║\_____/  \___| \_/ /_/ /_/ /_/ |___/\___| ║
-  ║                                          ║
-  ║   Multi-Agent Software Development       ║
-  ╚══════════════════════════════════════════╝
-"""
+from storage.checkpoint import CheckpointStore
 
-HELP_TEXT = """
-  Commands:
-    :do, :d <desc>      Submit a task from description
-    :status, :st         Show system status
-    :log, :l <id>        Show task execution timeline
-    :review, :rv         Review pending escalations
-    :resolve, :rs <id>   Resolve an escalation
-    :tasks, :t           List all tasks
-    :watch <id>          Watch a specific task in detail
-    :quit, :q            Exit DevHive
-
-  Shortcuts:
-    !<cmd>               Escape to shell (e.g., !git status)
-    Ctrl+C               Interrupt current operation
-
-  From terminal:
-    dh do "description"  Quick task submission
-    dh status            Quick status check
-    dh review            Quick escalation review
-"""
+VERSION = "0.1.4"
+console = Console()
+
+BANNER = """
+  [bold cyan]DevHive[/] — Multi-Agent Software Development
+  Version {version}  │  :help for commands  │  Ctrl+C to quit
+""".format(version=VERSION)
 
 
 # ── Config ──────────────────────────────────────────────────
 
-def load_config(config_path: str = None) -> dict:
-    """Load YAML config, resolving env vars."""
+def load_config(path: str = None) -> dict:
     import yaml
-    paths = [
-        config_path,
-        os.path.join(os.path.dirname(__file__), "..", "config.yaml"),
-        os.path.join(os.path.dirname(__file__), "..", "config.local.yaml"),
-        os.path.expanduser("~/.config/devhive/config.yaml"),
-    ]
+    paths = [path, "config.yaml", "config.local.yaml",
+             os.path.expanduser("~/.config/devhive/config.yaml")]
     for p in paths:
-        if p and os.path.exists(p):
+        if p and os.path.isfile(p):
             with open(p) as f:
                 raw = f.read()
-            # Resolve ${VAR} placeholders
-            import re
-            def _sub(m):
-                return os.environ.get(m.group(1), m.group(0))
-            raw = re.sub(r'\$\{(\w+)\}', _sub, raw)
+            raw = re.sub(r'\$\{(\w+)\}', lambda m: os.environ.get(m.group(1), m.group(0)), raw)
             return yaml.safe_load(raw)
     return {}
 
 
-# ── Natural Language Task Parsing ────────────────────────────
+# ── Task parsing ────────────────────────────────────────────
 
-async def parse_task_from_nl(description: str, priority: str = "MEDIUM",
-                             config: dict = None) -> TaskSpec:
-    """Use the model to parse a natural language description into a TaskSpec."""
+async def parse_task(description: str, priority: str = "MEDIUM", config: dict = None) -> TaskSpec:
     from tools.api_client import APIClient, extract_text_from_response
-
-    config = config or {}
-    api_cfg = config.get("api", {})
-    client = APIClient(
-        base_url=api_cfg.get("base_url"),
-        auth_token=api_cfg.get("auth_token"),
-        default_model=api_cfg.get("default_model"),
-    )
-
-    system = """You are a task parser. Convert the user's natural language description
-into a structured JSON task specification. Output ONLY the JSON, no explanation.
-
-Format:
-{
-  "title": "concise one-line title",
-  "description": "expanded description with context and requirements",
-  "acceptance_criteria": ["criterion 1", "criterion 2"],
-  "scope_constraints": ["constraint 1"],
-  "sensitive_modules": [],
-  "priority": "MEDIUM"
-}
-
-Rules:
-- title: one line, action-oriented (start with a verb)
-- description: include what, why, and any context the user provided
-- acceptance_criteria: specific, testable conditions of done
-- scope_constraints: what NOT to touch
-- sensitive_modules: detect if auth/payment/data/permission is involved
-- priority: use the provided priority if specified
-"""
+    cfg = (config or {}).get("api", {})
+    client = APIClient(base_url=cfg.get("base_url"), auth_token=cfg.get("auth_token"),
+                       default_model=cfg.get("default_model"))
 
     response = await client.create_message(
-        system=system,
+        system="Convert user request to JSON task spec. Output ONLY valid JSON, no explanation.\n"
+               'Format: {"title":"...","description":"...","acceptance_criteria":[...],'
+               '"scope_constraints":[...],"sensitive_modules":[...],"priority":"MEDIUM"}',
         messages=[{"role": "user", "content": f"Priority: {priority}\n\n{description}"}],
-        max_tokens=1024,
-        temperature=0.1,
-    )
+        max_tokens=1024, temperature=0.1)
 
     text = extract_text_from_response(response)
-
-    # Extract JSON
-    import re
-    match = re.search(r'\{.*\}', text, re.DOTALL)
-    if match:
-        data = json.loads(match.group(0))
-    else:
-        # Fallback: build simple spec
-        data = {
-            "title": description[:80],
-            "description": description,
-            "acceptance_criteria": [],
-            "scope_constraints": [],
-            "sensitive_modules": [],
-            "priority": priority,
-        }
-
+    m = re.search(r'\{.*\}', text, re.DOTALL)
+    data = json.loads(m.group(0)) if m else {"title": description[:80], "description": description}
     return TaskSpec(
         title=data.get("title", description[:80]),
         description=data.get("description", description),
         acceptance_criteria=data.get("acceptance_criteria", []),
         scope_constraints=data.get("scope_constraints", []),
         sensitive_modules=data.get("sensitive_modules", []),
-        priority=Priority(data.get("priority", priority)),
-    )
+        priority=Priority(data.get("priority", priority)))
+
 
+# ── REPL ────────────────────────────────────────────────────
 
-# ── Interactive REPL ────────────────────────────────────────
+HELP = """
+  [bold]:do, :d <desc>[/]       Submit task from natural language
+  [bold]:status, :st[/]          Show pending tasks & escalations
+  [bold]:tasks, :t[/]            List all tasks
+  [bold]:log, :l <id>[/]         Show task execution timeline
+  [bold]:review, :rv[/]          Review and resolve escalations
+  [bold]:resolve, :rs <id>[/]    Resolve an escalation by ID
+  [bold]:watch <id>[/]           Zoom into a specific task
+  [bold]:help, :h[/]             Show this help
+  [bold]:quit, :q[/]             Exit
+
+  [bold]!<cmd>[/]                 Escape to shell
+  [dim]Bare text → auto-submit as task[/]
+"""
 
-class DevHiveREPL:
-    """Interactive REPL with live dashboard."""
 
+class REPL:
     def __init__(self, config: dict):
         self.config = config
-        self.console = Console()
-        self.orchestrator: Optional[Orchestrator] = None
-        self.tui = DevHiveTUI()
-        self._running = False
-        self._command_task: Optional[asyncio.Task] = None
+        self.orch: Optional[Orchestrator] = None
+        self.store: Optional[CheckpointStore] = None
+        self.selected_task: Optional[str] = None
 
     async def start(self):
-        """Start orchestrator and enter interactive loop."""
-        self.console.print(BANNER, style="bold cyan")
-        self.console.print(f"  Version {VERSION}", style="dim")
-        model = self.config.get("api", {}).get("default_model", "unknown")
-        self.console.print(f"  Model: {model}", style="dim")
-        self.console.print()
-
-        # Start orchestrator
-        self.orchestrator = Orchestrator(self.config)
-        self.tui._orchestrator = self.orchestrator
-
-        # Start orchestrator in background
-        orchestrator_task = asyncio.create_task(
-            self.orchestrator.start(agent_counts={"execute": 1})
-        )
-        await asyncio.sleep(0.5)  # Let it initialize
-
-        self.tui.log_activity("system", "Orchestrator started")
-        self._running = True
-
-        # Start TUI refresh and command input concurrently
-        try:
-            await self._repl_loop()
-        except (KeyboardInterrupt, EOFError):
-            pass
-        finally:
-            self._running = False
-            await self.orchestrator.stop()
-            orchestrator_task.cancel()
-            try:
-                await orchestrator_task
-            except asyncio.CancelledError:
-                pass
-
-        self.console.print("\n  DevHive stopped.", style="dim")
-
-    async def _repl_loop(self):
-        """Main REPL: live dashboard + command input."""
-        from rich.live import Live
-        from prompt_toolkit import PromptSession
-        from prompt_toolkit.history import FileHistory
-        from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
-
-        # Try prompt_toolkit for fancy input; fall back to input()
+        console.print(BANNER)
+
+        self.orch = Orchestrator(self.config)
+        self.store = self.orch.checkpoint
+        asyncio.create_task(self.orch.start(agent_counts={"execute": 1}))
+        await asyncio.sleep(0.5)
+
         try:
-            session = PromptSession(
-                history=FileHistory(os.path.expanduser("~/.devhive_history")),
-                auto_suggest=AutoSuggestFromHistory(),
-            )
-            use_prompt_toolkit = True
-        except ImportError:
-            session = None
-            use_prompt_toolkit = False
-
-        with Live(self.tui.render(), console=self.console,
-                  refresh_per_second=4, screen=True) as live:
-
-            # Background task to push TUI updates
-            async def _refresh_tui():
-                while self._running:
-                    live.update(self.tui.render())
-                    await asyncio.sleep(0.25)
-
-            refresh_task = asyncio.create_task(_refresh_tui())
-
-            # Command input loop
-            while self._running:
+            while True:
                 try:
-                    live.stop()  # Pause TUI for input
-                    if use_prompt_toolkit:
-                        cmd = await asyncio.get_event_loop().run_in_executor(
-                            None, lambda: session.prompt("dh> "))
-                    else:
-                        cmd = await asyncio.get_event_loop().run_in_executor(
-                            None, lambda: input("dh> "))
-                    live.start()
-
-                    if cmd:
-                        await self._handle_command(cmd.strip())
-                except (KeyboardInterrupt, EOFError):
+                    cmd = await asyncio.get_event_loop().run_in_executor(
+                        None, lambda: input("dh> "))
+                except (EOFError, KeyboardInterrupt):
                     break
-                except Exception as e:
-                    self.tui.log_activity("error", str(e))
-
-            refresh_task.cancel()
-            try:
-                await refresh_task
-            except asyncio.CancelledError:
-                pass
+                if cmd:
+                    await self._dispatch(cmd.strip())
+        finally:
+            await self.orch.stop()
 
-    async def _handle_command(self, cmd: str):
-        """Dispatch a REPL command."""
+    async def _dispatch(self, cmd: str):
         # Shell escape
         if cmd.startswith("!"):
-            shell_cmd = cmd[1:].strip()
-            if shell_cmd:
-                self.tui.log_activity("shell", shell_cmd)
-                try:
-                    result = subprocess.run(
-                        shell_cmd, shell=True, capture_output=True,
-                        text=True, timeout=30
-                    )
-                    output = result.stdout or result.stderr
-                    for line in output.strip().split("\n")[:20]:
-                        self.tui.log_activity("shell", line)
-                except Exception as e:
-                    self.tui.log_activity("shell", f"Error: {e}")
+            self._shell(cmd[1:].strip())
             return
 
-        # Colon commands
+        # Colon command or bare text
         if cmd.startswith(":"):
             parts = shlex.split(cmd)
-            cmd_name = parts[0][1:].lower() if parts else ""
-            args = parts[1:] if len(parts) > 1 else []
+            name = parts[0][1:].lower()
+            args = parts[1:]
         else:
-            # Bare text → submit as task
-            cmd_name = "do"
+            name = "do"
             args = [cmd]
 
-        match cmd_name:
-            case "help" | "h":
-                self.console.print(HELP_TEXT, style="dim")
-                self.tui.log_activity("system", "Showed help")
-
-            case "quit" | "q" | "exit":
-                self._running = False
-                self.tui.log_activity("system", "Shutting down...")
-
-            case "do" | "d":
-                await self._cmd_submit(" ".join(args) if args else "")
-
-            case "status" | "st":
-                await self._cmd_show_status()
-
-            case "tasks" | "t":
-                await self._cmd_list_tasks()
-
-            case "log" | "l":
-                await self._cmd_show_log(args[0] if args else None)
-
-            case "review" | "rv":
-                await self._cmd_review()
-
-            case "resolve" | "rs":
-                if args:
-                    await self._cmd_resolve(args[0])
-
-            case "watch" | "w":
-                if args:
-                    self.tui._selected_task = args[0]
-                    self.tui.log_activity("system", f"Watching task {args[0]}")
-
-            case _:
-                # Unknown command → treat as task description
-                desc = cmd[1:] if cmd.startswith(":") else cmd
-                await self._cmd_submit(desc)
+        match name:
+            case "help" | "h": console.print(HELP)
+            case "quit" | "q" | "exit": raise EOFError
+            case "do" | "d": await self._do(" ".join(args))
+            case "status" | "st": await self._status()
+            case "tasks" | "t": await self._tasks()
+            case "log" | "l": await self._log(args[0] if args else None)
+            case "review" | "rv": await self._review()
+            case "resolve" | "rs": await self._resolve(args[0] if args else "")
+            case "watch" | "w": self.selected_task = args[0] if args else self.selected_task
+            case _: await self._do(cmd if not cmd.startswith(":") else cmd[1:])
+
+    def _shell(self, cmd: str):
+        if not cmd: return
+        try:
+            r = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=30)
+            if r.stdout: console.print(r.stdout.rstrip(), style="dim")
+            if r.stderr: console.print(r.stderr.rstrip(), style="red")
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/]")
 
-    async def _cmd_submit(self, description: str):
-        """Submit a new task."""
+    async def _do(self, description: str):
         if not description:
-            self.tui.log_activity("error", "Usage: :do <description>")
-            return
-
-        self.tui.log_activity("system", f"Parsing: {description[:60]}...")
-
+            console.print("[red]Usage: :do <description>[/]"); return
+        console.print(f"[dim]Parsing...[/]")
         try:
-            spec = await parse_task_from_nl(description, config=self.config)
-            task_id = await self.orchestrator.submit_task(spec)
-            self.tui.update_task(task_id, "SPECIFY", "parsed",
-                                spec.title)
-            self.tui.log_activity("task", f"Created {task_id[-16:]}: {spec.title}")
-            self.console.print(f"  ✓ Task created: {task_id}", style="green")
+            spec = await parse_task(description, config=self.config)
+            tid = await self.orch.submit_task(spec)
+            console.print(Panel(
+                f"Title: {spec.title}\nPriority: {spec.priority.value}\nID: {tid}",
+                title="[green]✓ Task Created[/]", border_style="green"))
         except Exception as e:
-            self.tui.log_activity("error", f"Failed: {e}")
-
-    async def _cmd_show_status(self):
-        """Show system status."""
-        store = self.orchestrator.checkpoint
-        tasks = store.get_pending_tasks()
-        escs = store.get_open_escalations()
-        status_display(tasks, escs)
-
-    async def _cmd_list_tasks(self):
-        """List all tasks in the TUI detail panel."""
-        store = self.orchestrator.checkpoint
-        tasks = store.get_pending_tasks()
+            console.print(f"[red]Failed: {e}[/]")
+
+    async def _status(self):
+        tasks = self.store.get_pending_tasks()
+        escs = self.store.get_open_escalations()
+        t = Table(title="Status", box=box.ROUNDED)
+        t.add_column("Metric"); t.add_column("Count")
+        t.add_row("Pending tasks", str(len(tasks)))
+        t.add_row("Open escalations", str(len(escs)))
+        console.print(t)
+        for e in escs[:5]:
+            console.print(f"  [red]⚠[/] {e.get('id','?')[:30]}  task: {e.get('task_id','?')[-20:]}")
+        console.print()
+
+    async def _tasks(self):
+        tasks = self.store.get_pending_tasks()
+        if not tasks:
+            console.print("[dim]No pending tasks.[/]"); return
         for t in tasks:
             stage = t.get("current_stage", "?")
-            self.tui.update_task(t["id"], stage, t.get("status", ""),
-                                t.get("spec_json", "{}")[:80])
-        self.tui.log_activity("system", f"Loaded {len(tasks)} tasks")
-
-    async def _cmd_show_log(self, task_id: str = None):
-        """Show task execution timeline."""
-        if not task_id:
-            task_id = self.tui._selected_task
-        if not task_id:
-            self.tui.log_activity("error", "Usage: :log <task-id>")
-            return
-
-        store = self.orchestrator.checkpoint
-        history = store.get_task_history(task_id)
-        task_timeline(history)
-
-    async def _cmd_review(self):
-        """Interactive escalation review."""
-        store = self.orchestrator.checkpoint
-        escs = store.get_open_escalations()
-        selected = escalation_review(escs)
-        if selected:
-            self.console.print(f"\n  Resolving {selected}...")
-            store.resolve_escalation(selected, "human-operator")
-            self.tui.log_activity("system", f"Resolved escalation {selected[:20]}...")
-            self.console.print("  ✓ Resolved", style="green")
-
-    async def _cmd_resolve(self, esc_id: str):
-        """Resolve an escalation by ID."""
-        self.orchestrator.checkpoint.resolve_escalation(esc_id, "human-operator")
-        self.tui.log_activity("system", f"Resolved {esc_id[:20]}...")
-        self.console.print(f"  ✓ Escalation resolved", style="green")
+            console.print(f"  • {t['id'][-20:]}  [{stage}]  {t.get('status','pending')}")
+
+    async def _log(self, tid: str = None):
+        tid = tid or self.selected_task
+        if not tid:
+            console.print("[red]Usage: :log <task-id>[/]"); return
+        history = self.store.get_task_history(tid)
+        if not history:
+            console.print("[dim]No history found.[/]"); return
+        console.print(f"[bold]── {tid} ──[/]")
+        for h in history:
+            icon = "✓" if h["outcome"] in ("COMPLETED","PASS") else "✗" if h["outcome"]=="FAIL" else "●"
+            console.print(f"  {icon} [{h['stage']}] {h['outcome']}  [dim]{h['created_at']}[/]")
+
+    async def _review(self):
+        escs = self.store.get_open_escalations()
+        if not escs:
+            console.print("[green]No open escalations![/]"); return
+        for i, e in enumerate(escs):
+            console.print(f"  [{i+1}] {e['id'][:30]}\n     task: {e.get('task_id','?')[-30:]}\n     {e.get('created_at','?')}")
+        try:
+            ch = input("  Select [1-N] or Enter to skip: ").strip()
+            if ch.isdigit():
+                idx = int(ch) - 1
+                if 0 <= idx < len(escs):
+                    self.store.resolve_escalation(escs[idx]["id"], "human")
+                    console.print(f"[green]✓ Resolved[/]")
+        except (EOFError, KeyboardInterrupt): pass
 
+    async def _resolve(self, eid: str):
+        if not eid:
+            console.print("[red]Usage: :resolve <escalation-id>[/]"); return
+        self.store.resolve_escalation(eid, "human")
+        console.print(f"[green]✓ Resolved {eid[:30]}[/]")
 
-# ── One-shot Commands ───────────────────────────────────────
 
-async def cmd_do(args, config: dict):
-    """Quick task submission from the command line."""
-    console = Console()
-    console.print(BANNER, style="bold cyan")
+# ── One-shot commands ───────────────────────────────────────
 
+async def cmd_do(args, config):
+    console.print(BANNER)
     if args.file:
         import yaml
         with open(args.file) as f:
             data = json.load(f) if args.file.endswith(".json") else yaml.safe_load(f)
         spec = TaskSpec(**data)
-        console.print(f"  Loaded spec from {args.file}", style="dim")
     elif args.description:
-        console.print("  Parsing task description...", style="dim")
-        spec = await parse_task_from_nl(
-            args.description,
-            priority=args.priority or "MEDIUM",
-            config=config,
-        )
-        console.print(f"  Title: {spec.title}", style="bold")
-        console.print(f"  Priority: {spec.priority.value}", style="dim")
+        spec = await parse_task(args.description, args.priority or "MEDIUM", config)
     else:
-        console.print("  Usage: dh do <description>  or  dh do -f <file>", style="red")
-        return
-
+        console.print("[red]Usage: dh do <description> or dh do -f <file>[/]"); return
     orch = Orchestrator(config)
     await orch.start(agent_counts={"execute": 1})
     await asyncio.sleep(0.3)
-
-    task_id = await orch.submit_task(spec)
-    console.print(f"\n  ✓ Task submitted: {task_id}", style="green")
-
-    # Wait briefly for execution to start
-    await asyncio.sleep(2)
-
-    # Show task status
-    history = orch.checkpoint.get_task_history(task_id)
-    if history:
-        task_timeline(history)
-
+    tid = await orch.submit_task(spec)
+    console.print(f"[green]✓ Submitted: {tid}[/]")
+    console.print(f"  Title: {spec.title}")
     await orch.stop()
 
-
-async def cmd_status(args, config: dict):
-    """Quick status check."""
+async def cmd_status(args, config):
     orch = Orchestrator(config)
     await orch.start(agent_counts={})
-    await asyncio.sleep(0.3)
-
-    tasks = orch.checkpoint.get_pending_tasks()
-    escs = orch.checkpoint.get_open_escalations()
-    status_display(tasks, escs)
-
+    await asyncio.sleep(0.2)
+    store = orch.checkpoint
+    tasks = store.get_pending_tasks()
+    escs = store.get_open_escalations()
+    console.print(f"Pending tasks: {len(tasks)}  |  Open escalations: {len(escs)}")
+    for e in escs:
+        console.print(f"  [red]⚠[/] {e['id'][:30]}")
     await orch.stop()
 
-
-async def cmd_log(args, config: dict):
-    """Show task timeline."""
+async def cmd_log(args, config):
     orch = Orchestrator(config)
     await orch.start(agent_counts={})
-
     history = orch.checkpoint.get_task_history(args.task_id)
-    task_timeline(history)
-
+    for h in history:
+        console.print(f"  [{h['stage']}] {h['outcome']}  [dim]{h['created_at']}[/]")
     await orch.stop()
 
-
-async def cmd_review(args, config: dict):
-    """Interactive escalation review."""
+async def cmd_review(args, config):
     orch = Orchestrator(config)
     await orch.start(agent_counts={})
-
     escs = orch.checkpoint.get_open_escalations()
-    selected = escalation_review(escs)
-
-    if selected:
-        orch.checkpoint.resolve_escalation(selected, "human-operator")
-        Console().print(f"\n  ✓ Resolved", style="green")
-
+    if not escs:
+        console.print("[green]No escalations[/]")
+    else:
+        for i, e in enumerate(escs):
+            console.print(f"  [{i+1}] {e['id'][:30]}")
+        try:
+            ch = input("Select: ").strip()
+            if ch.isdigit():
+                e = escs[int(ch)-1]
+                orch.checkpoint.resolve_escalation(e["id"], "human")
+                console.print("[green]✓ Resolved[/]")
+        except (EOFError, KeyboardInterrupt): pass
     await orch.stop()
 
-
-async def cmd_resolve(args, config: dict):
-    """Resolve an escalation."""
+async def cmd_resolve(args, config):
     orch = Orchestrator(config)
     await orch.start(agent_counts={})
-    orch.checkpoint.resolve_escalation(args.escalation_id, "human-operator")
-    Console().print(f"  ✓ Resolved {args.escalation_id}", style="green")
+    orch.checkpoint.resolve_escalation(args.escalation_id, "human")
+    console.print(f"[green]✓ Resolved[/]")
     await orch.stop()
 
-
-# ── Daemon ──────────────────────────────────────────────────
-
-async def cmd_run(args, config: dict):
-    """Start orchestrator daemon (for long-running use)."""
-    console = Console()
-    console.print(BANNER, style="bold cyan")
-    console.print("  Starting DevHive daemon...", style="dim")
-
+async def cmd_run(args, config):
     orch = Orchestrator(config)
-    await orch.start(agent_counts=args.agents)
-    console.print("  ✓ Daemon running. Press Ctrl+C to stop.", style="green")
-    console.print()
-
-    try:
-        await asyncio.Event().wait()
-    except KeyboardInterrupt:
-        console.print("\n  Shutting down...", style="dim")
-        await orch.stop()
+    await orch.start(agent_counts={"execute": args.agents or 1})
+    console.print("[green]Daemon running. Ctrl+C to stop.[/]")
+    try: await asyncio.Event().wait()
+    except KeyboardInterrupt: await orch.stop()
 
 
-# ── Entry Point ─────────────────────────────────────────────
+# ── Entry point ─────────────────────────────────────────────
 
 def main():
-    parser = argparse.ArgumentParser(
-        prog="dh",
-        description="DevHive — Multi-Agent Software Development System",
-    )
-    parser.add_argument("-c", "--config", help="Config file path")
-    parser.add_argument("-v", "--version", action="version",
-                        version=f"DevHive {VERSION}")
+    parser = argparse.ArgumentParser(prog="dh", description="DevHive CLI")
+    parser.add_argument("-c", "--config")
+    parser.add_argument("-v", "--version", action="version", version=f"DevHive {VERSION}")
     sub = parser.add_subparsers(dest="command")
 
-    # dh (no args) → interactive REPL
-    # (handled by checking if command is None below)
-
-    # dh do
-    p_do = sub.add_parser("do", help="Submit a task")
-    p_do.add_argument("description", nargs="?", help="Task description in natural language")
-    p_do.add_argument("-f", "--file", help="Task spec JSON/YAML file")
-    p_do.add_argument("-p", "--priority", choices=["CRITICAL", "HIGH", "MEDIUM", "LOW"])
-
-    # dh run
-    p_run = sub.add_parser("run", help="Start orchestrator daemon")
-    p_run.add_argument("-a", "--agents", type=int, default=1,
-                       help="Number of execute agents")
-
-    # dh status
-    sub.add_parser("status", help="Show system status")
-
-    # dh log
-    p_log = sub.add_parser("log", help="Show task execution timeline")
-    p_log.add_argument("task_id", help="Task ID")
-
-    # dh review
-    sub.add_parser("review", help="Interactive escalation review")
-
-    # dh resolve
-    p_resolve = sub.add_parser("resolve", help="Resolve an escalation")
-    p_resolve.add_argument("escalation_id", help="Escalation ID")
+    p_do = sub.add_parser("do"); p_do.add_argument("description", nargs="?")
+    p_do.add_argument("-f", "--file"); p_do.add_argument("-p", "--priority",
+        choices=["CRITICAL","HIGH","MEDIUM","LOW"])
+    p_run = sub.add_parser("run"); p_run.add_argument("-a", "--agents", type=int)
+    sub.add_parser("status")
+    p_log = sub.add_parser("log"); p_log.add_argument("task_id")
+    sub.add_parser("review")
+    p_res = sub.add_parser("resolve"); p_res.add_argument("escalation_id")
 
     args = parser.parse_args()
     config = load_config(args.config)
 
-    if args.command is None:
-        # Interactive REPL mode
-        repl = DevHiveREPL(config)
-        try:
-            asyncio.run(repl.start())
-        except KeyboardInterrupt:
-            pass
+    if args.command == "run":
+        asyncio.run(cmd_run(args, config))
     elif args.command == "do":
         asyncio.run(cmd_do(args, config))
-    elif args.command == "run":
-        asyncio.run(cmd_run(args, config))
     elif args.command == "status":
         asyncio.run(cmd_status(args, config))
     elif args.command == "log":
@@ -590,6 +338,10 @@ def main():
         asyncio.run(cmd_review(args, config))
     elif args.command == "resolve":
         asyncio.run(cmd_resolve(args, config))
+    else:
+        repl = REPL(config)
+        try: asyncio.run(repl.start())
+        except (KeyboardInterrupt, EOFError): pass
 
 
 if __name__ == "__main__":

package/control_plane/tui.py

@@ -63,6 +63,7 @@ class DevHiveTUI:
         self._tasks: dict = {}
         self._selected_task: Optional[str] = None
         self._running = False
+        self._output_lines: list[str] = []  # command output shown in detail pane
 
     def log_activity(self, source: str, message: str):
         """Add an entry to the activity feed."""
@@ -78,6 +79,10 @@ class DevHiveTUI:
     def set_tasks(self, tasks: dict):
         self._tasks = tasks
 
+    def show(self, *lines: str):
+        """Set output lines to display in the detail panel. Auto-clears after next update."""
+        self._output_lines = list(lines)
+
     @property
     def uptime(self) -> str:
         seconds = int(time.monotonic() - self._start_time)
@@ -158,7 +163,15 @@ class DevHiveTUI:
                     title_align="left")
 
     def _detail_panel(self) -> Panel:
-        """Detail view for selected or most recent task."""
+        """Detail view for selected task, output, or command results."""
+
+        # Output mode: show command output when available
+        if self._output_lines:
+            text = Text("\n").join(Text(line) for line in self._output_lines)
+            panel = Panel(text, title="Output", border_style="bright_cyan",
+                         title_align="left")
+            return panel
+
         if self._selected_task and self._selected_task in self._tasks:
             tasks_to_show = {self._selected_task: self._tasks[self._selected_task]}
         elif self._tasks:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oswaldzsh/devhive",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Multi-Agent Software Development System — autonomous coding with verify-specialized agents, failure signatures, and structured handoff protocols.",
   "keywords": [
     "ai",