feat: polish cli and tui (#35)

Author: Gusarich

src/cli.py

@@ -267,11 +267,7 @@ def create_parser(cls) -> argparse.ArgumentParser:
         g_limits.add_argument(
             "--timeout", type=int, default=3600, help="Timeout per instance (seconds)"
         )
-        g_limits.add_argument(
-            "--parallel",
-            choices=["conservative", "balanced", "aggressive"],
-            help="Preset resources: 1C/2G, 2C/4G, 3C/6-8G",
-        )
+        # Legacy parallel presets removed; use --max-parallel or auto
         g_limits.add_argument(
             "--allow-global-session-volume",
             action="store_true",
@@ -1573,12 +1569,9 @@ async def run_orchestrator(self, args: argparse.Namespace) -> int:
         if args.show_run:
             return await self.run_show_run(args)
 
-        # Check for prompt or resume
-        if not args.prompt and not args.resume and not args.resume_fresh:
-            self.console.print(
-                "[red]Error: Either provide a prompt or use --resume/--resume-fresh[/red]"
-            )
-            return 1
+        # Normalize missing prompt to empty string and let strategies validate if needed
+        if not args.resume and not args.resume_fresh:
+            args.prompt = getattr(args, "prompt", "") or ""
 
         # Perform pre-flight checks for new runs
         if not args.resume and not args.resume_fresh:
@@ -1786,20 +1779,7 @@ def _red(k, v):
         # Store allow flags for constructor
         allow_overwrite = bool(getattr(args, "allow_overwrite_protected_refs", False))
 
-        # Apply parallel preset before building limits
-        preset = getattr(args, "parallel", None)
-        if preset:
-            runner = full_config.setdefault("runner", {})
-            if preset == "conservative":
-                runner["cpu_limit"] = 1
-                runner["memory_limit"] = "2g"
-            elif preset == "balanced":
-                runner["cpu_limit"] = 2
-                runner["memory_limit"] = "4g"
-            elif preset == "aggressive":
-                runner["cpu_limit"] = 3
-                # Allow operator to override memory via env/config; default 6g
-                runner["memory_limit"] = runner.get("memory_limit", "6g")
+        # Parallel presets removed. Concurrency is either auto (default) or explicitly set via --max-parallel.
 
         # Configure container limits from merged config
         memory_limit_str = full_config["runner"]["memory_limit"]

src/orchestration/orchestrator.py

@@ -74,6 +74,7 @@ def __init__(
         default_docker_image: Optional[str] = None,
         default_agent_cli_args: Optional[List[str]] = None,
         force_commit: bool = False,
+        explicit_max_parallel: bool = False,
     ):
         """
         Initialize orchestrator.
@@ -107,6 +108,8 @@ def __init__(
             self.default_agent_cli_args = []
         # Runner behavior: force a commit if workspace has changes
         self.force_commit: bool = bool(force_commit)
+        # Whether operator explicitly set max_parallel (override guards/policies)
+        self._explicit_max_parallel = bool(explicit_max_parallel)
         # Load model mapping checksum for handshake (single-process still validates equality)
         try:
             from ..utils.model_mapping import load_model_mapping
@@ -251,9 +254,11 @@ async def initialize(self) -> None:
                 logger.info(
                     f"Parallelism(auto): host_cpu={host_cpu}, per_container={per_container} -> max_parallel_instances={adaptive}"
                 )
-            # Oversubscription warning
+            # Oversubscription warning only when not explicit
             try:
-                if (int(self.max_parallel_instances) * per_container) > host_cpu:
+                if (
+                    int(self.max_parallel_instances) * per_container
+                ) > host_cpu and not getattr(self, "_explicit_max_parallel", False):
                     logger.warning(
                         f"Configured parallelism may oversubscribe CPU: max_parallel_instances={self.max_parallel_instances}, per_container_cpu={per_container}, host_cpu={host_cpu}"
                     )
@@ -266,8 +271,11 @@ async def initialize(self) -> None:
         self._resource_pool = asyncio.Semaphore(int(self.max_parallel_instances or 1))
 
         # Start multiple background executors for true parallel execution
-        # Start a reasonable number of executors (min of max_parallel and 10)
-        num_executors = min(int(self.max_parallel_instances or 1), 10)
+        # If explicit max-parallel set, honor fully; otherwise cap at 10
+        if getattr(self, "_explicit_max_parallel", False):
+            num_executors = int(self.max_parallel_instances or 1)
+        else:
+            num_executors = min(int(self.max_parallel_instances or 1), 10)
         for i in range(num_executors):
             task = asyncio.create_task(self._instance_executor())
             self._executor_tasks.append(task)
@@ -1359,13 +1367,21 @@ async def _admission_wait(self, cpu_need: int, mem_need_gb: int) -> None:
                 slope = 0.0
 
             async with self._admission_lock:
-                cpu_ok = (self._cpu_in_use + cpu_need) <= self._host_cpu
-                mem_ok = (self._mem_in_use_gb + mem_need_gb) <= int(
-                    self._host_mem_gb * self._mem_guard_pct
-                )
-                disk_ok = (free_gb >= self._disk_min_free_gb) and (
-                    slope <= self._pack_max_slope_mib_per_min
-                )
+                if getattr(self, "_explicit_max_parallel", False):
+                    # Honor operator's explicit parallel setting: bypass CPU/memory guard; keep disk guard
+                    disk_ok = (free_gb >= self._disk_min_free_gb) and (
+                        slope <= self._pack_max_slope_mib_per_min
+                    )
+                    cpu_ok = True
+                    mem_ok = True
+                else:
+                    cpu_ok = (self._cpu_in_use + cpu_need) <= self._host_cpu
+                    mem_ok = (self._mem_in_use_gb + mem_need_gb) <= int(
+                        self._host_mem_gb * self._mem_guard_pct
+                    )
+                    disk_ok = (free_gb >= self._disk_min_free_gb) and (
+                        slope <= self._pack_max_slope_mib_per_min
+                    )
 
                 if cpu_ok and mem_ok and disk_ok:
                     self._cpu_in_use += cpu_need

src/orchestration/strategies/best_of_n.py

@@ -11,6 +11,7 @@
 from typing import List, TYPE_CHECKING
 
 from ...shared import InstanceResult
+from ...exceptions import StrategyError
 from .base import Strategy, StrategyConfig
 from .scoring import ScoringStrategy
 
@@ -76,6 +77,8 @@ async def execute(
         Returns:
             List containing the best scoring result
         """
+        if not (prompt or "").strip():
+            raise StrategyError("best-of-n: prompt is required (non-empty)")
         config = self.create_config()
         logger.info(f"BestOfNStrategy starting with n={config.n}")
 

src/orchestration/strategies/iterative.py

@@ -9,6 +9,7 @@
 from typing import List, TYPE_CHECKING
 
 from ...shared import InstanceResult
+from ...exceptions import StrategyError
 from .base import Strategy, StrategyConfig
 
 if TYPE_CHECKING:
@@ -65,6 +66,8 @@ async def execute(
         Returns:
             List containing the final refined result
         """
+        if not (prompt or "").strip():
+            raise StrategyError("iterative: prompt is required (non-empty)")
         config = self.create_config()
 
         # Start with the initial implementation

src/orchestration/strategies/scoring.py

@@ -10,8 +10,8 @@
 from typing import List, TYPE_CHECKING
 
 from ...shared import InstanceResult
-from .base import Strategy, StrategyConfig
 from ...exceptions import StrategyError
+from .base import Strategy, StrategyConfig
 
 if TYPE_CHECKING:
     from ..strategy_context import StrategyContext
@@ -67,6 +67,8 @@ async def execute(
         Returns:
             List containing the scored instance result
         """
+        if not (prompt or "").strip():
+            raise StrategyError("scoring: prompt is required (non-empty)")
         config = self.create_config()
 
         # Phase 1: Generate solution

src/orchestration/strategies/simple.py

@@ -9,6 +9,7 @@
 from typing import List, TYPE_CHECKING
 
 from ...shared import InstanceResult
+from ...exceptions import StrategyError
 from .base import Strategy, StrategyConfig
 
 if TYPE_CHECKING:
@@ -50,6 +51,8 @@ async def execute(
         Returns:
             List containing the single instance result
         """
+        if not (prompt or "").strip():
+            raise StrategyError("simple: prompt is required (non-empty)")
         logger.info(f"SimpleStrategy.execute called with prompt: {prompt[:50]}...")
 
         # Durable run with key

src/tui/adaptive.py

@@ -15,7 +15,7 @@
 from rich.console import Group
 
 from .models import RunDisplay, InstanceDisplay, InstanceStatus
-from datetime import datetime
+from datetime import datetime, timezone
 
 
 class AdaptiveDisplay:
@@ -30,6 +30,14 @@ def __init__(self):
         }
         self._color_scheme = "default"  # default|accessible
 
+    def _aware(self, dt: datetime | None) -> datetime:
+        """Return a timezone-aware datetime (UTC) for safe comparisons/sorts."""
+        if dt is None:
+            return datetime.now(timezone.utc)
+        if dt.tzinfo is None:
+            return dt.replace(tzinfo=timezone.utc)
+        return dt
+
     def set_color_scheme(self, scheme: str) -> None:
         s = (scheme or "default").strip().lower()
         if s not in ("default", "accessible"):
@@ -108,7 +116,7 @@ def _render_detailed(self, run: RunDisplay, frame_now=None) -> RenderableType:
                 strategy_instances,
                 key=lambda i: (
                     status_order.get(i.status, 3),
-                    i.started_at or datetime.now(),
+                    self._aware(i.started_at),
                 ),
             )
             # Create instance panels
@@ -333,7 +341,7 @@ def _render_compact(self, run: RunDisplay, frame_now=None) -> RenderableType:
             key=lambda i: (
                 i.strategy_name,
                 status_order.get(i.status, 3),
-                i.started_at or datetime.now(),
+                self._aware(i.started_at),
             ),
         )
 
@@ -434,7 +442,7 @@ def _render_compact(self, run: RunDisplay, frame_now=None) -> RenderableType:
 
         return Panel(table, border_style="blue", padding=(0, 1))
 
-    def _render_dense(self, run: RunDisplay) -> RenderableType:
+    def _render_dense(self, run: RunDisplay, frame_now=None) -> RenderableType:
         """Render dense view for >30 instances with minimal per-instance lines (phase/runtime)."""
         panels = []
         try:
@@ -463,7 +471,7 @@ def _render_dense(self, run: RunDisplay) -> RenderableType:
                 items,
                 key=lambda i: (
                     status_order.get(i.status, 3),
-                    i.started_at or datetime.now(),
+                    self._aware(i.started_at),
                 ),
             )
             table = Table(show_header=False, expand=True, padding=(0, 1))
@@ -492,11 +500,18 @@ def _render_dense(self, run: RunDisplay) -> RenderableType:
                 try:
                     secs = inst.duration_seconds or 0
                     if inst.status == InstanceStatus.RUNNING and inst.started_at:
-                        now = (
-                            datetime.now(inst.started_at.tzinfo)
-                            if inst.started_at.tzinfo
-                            else datetime.now()
-                        )
+                        if frame_now is not None:
+                            now = (
+                                frame_now
+                                if inst.started_at.tzinfo
+                                else frame_now.replace(tzinfo=None)
+                            )
+                        else:
+                            now = (
+                                datetime.now(inst.started_at.tzinfo)
+                                if inst.started_at.tzinfo
+                                else datetime.now()
+                            )
                         secs = max(secs, (now - inst.started_at).total_seconds())
                     if secs > 0:
                         dur = self._format_duration(secs)