@pjmendonca/devflow 1.13.2 → 1.19.0

package/tooling/scripts/run-collab.py

@@ -28,7 +28,7 @@ Examples:
 import argparse
 import json
 import os
-import platform
+import platform as platform_stdlib
 import shutil
 import sys
 from datetime import datetime
@@ -38,10 +38,9 @@ from typing import Optional
 SCRIPT_DIR = Path(__file__).parent
 sys.path.insert(0, str(SCRIPT_DIR / "lib"))
 
-# Cross-platform detection
-IS_WINDOWS = platform.system() == "Windows"
-IS_MACOS = platform.system() == "Darwin"
-IS_LINUX = platform.system() == "Linux"
+from platform import IS_MACOS, IS_WINDOWS
+
+from colors import Colors
 
 
 def detect_claude_cli() -> Optional[str]:
@@ -63,8 +62,8 @@ def detect_claude_cli() -> Optional[str]:
     if IS_WINDOWS:
         # Check common Windows install locations
         possible_paths = [
-            Path(os.environ.get("LOCALAPPDATA", "")) / "Programs" / "claude" / "claude.exe",
-            Path(os.environ.get("PROGRAMFILES", "")) / "Claude" / "claude.exe",
+            Path(os.getenv("LOCALAPPDATA", "")) / "Programs" / "claude" / "claude.exe",
+            Path(os.getenv("PROGRAMFILES", "")) / "Claude" / "claude.exe",
             Path.home() / ".claude" / "local" / "claude.exe",
             Path.home() / "AppData" / "Local" / "Programs" / "claude" / "claude.exe",
         ]
@@ -130,13 +129,13 @@ def get_config_dir() -> Path:
         Path to configuration directory.
     """
     if IS_WINDOWS:
-        base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+        base = Path(os.getenv("APPDATA") or str(Path.home() / "AppData" / "Roaming"))
         return base / "devflow"
     elif IS_MACOS:
         return Path.home() / "Library" / "Application Support" / "devflow"
     else:
         # Linux/Unix: Use XDG
-        xdg_data = os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share")
+        xdg_data = os.getenv("XDG_DATA_HOME") or str(Path.home() / ".local" / "share")
         return Path(xdg_data) / "devflow"
 
 
@@ -147,12 +146,12 @@ def get_cache_dir() -> Path:
         Path to cache directory.
     """
     if IS_WINDOWS:
-        base = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+        base = Path(os.getenv("LOCALAPPDATA") or str(Path.home() / "AppData" / "Local"))
         return base / "devflow" / "cache"
     elif IS_MACOS:
         return Path.home() / "Library" / "Caches" / "devflow"
     else:
-        xdg_cache = os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")
+        xdg_cache = os.getenv("XDG_CACHE_HOME") or str(Path.home() / ".cache")
         return Path(xdg_cache) / "devflow"
 
 
@@ -163,46 +162,18 @@ from lib.pair_programming import PairConfig, PairSession  # noqa: E402
 from lib.shared_memory import get_knowledge_graph, get_shared_memory, share_learning  # noqa: E402
 from lib.swarm_orchestrator import ConsensusType, SwarmConfig, SwarmOrchestrator  # noqa: E402
 
-
-# Colors for terminal output (with Windows support)
-class Colors:
-    """ANSI color codes with Windows compatibility."""
-
-    # Enable ANSI colors on Windows
-    if IS_WINDOWS:
-        try:
-            import ctypes
-
-            kernel32 = ctypes.windll.kernel32
-            kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
-        except Exception:
-            pass  # Fall back to no colors
-
-    # Check if colors should be enabled
-    _use_colors = (
-        sys.stdout.isatty()
-        and os.environ.get("NO_COLOR") is None
-        and os.environ.get("TERM") != "dumb"
+# Try to import validation loop
+try:
+    from lib.validation_loop import (
+        POST_COMPLETION_GATES,
+        PREFLIGHT_GATES,
+        LoopContext,
+        ValidationLoop,
     )
 
-    if _use_colors:
-        HEADER = "\033[95m"
-        BLUE = "\033[94m"
-        CYAN = "\033[96m"
-        GREEN = "\033[92m"
-        YELLOW = "\033[93m"
-        RED = "\033[91m"
-        BOLD = "\033[1m"
-        END = "\033[0m"
-    else:
-        HEADER = ""
-        BLUE = ""
-        CYAN = ""
-        GREEN = ""
-        YELLOW = ""
-        RED = ""
-        BOLD = ""
-        END = ""
+    HAS_VALIDATION = True
+except ImportError:
+    HAS_VALIDATION = False
 
 
 def print_banner():
@@ -314,8 +285,8 @@ def run_sequential_mode(story_key: str, task: str, agents: list[str], args: argp
         # Get context including handoffs
         context = handoff_gen.generate_context_for_agent(agent)
 
-        # Build prompt
-        f"""You are the {agent} agent.
+        # Build prompt for agent invocation
+        prompt = f"""You are the {agent} agent.
 
 {context}
 
@@ -329,6 +300,8 @@ Complete your part of this task according to your role.
 """
 
         # Invoke agent (simplified - in real use would call Claude CLI)
+        # Note: prompt is prepared above for when full agent invocation is implemented
+        _ = prompt  # Acknowledge prompt is ready for future use
         print("  -> Generating response...")
 
         # For demo, we'll note the handoff
@@ -379,7 +352,7 @@ def save_result(story_key: str, mode: str, result: dict):
                 "story_key": story_key,
                 "mode": mode,
                 "timestamp": datetime.now().isoformat(),
-                "platform": platform.system(),
+                "platform": platform_stdlib.system(),
                 "result": result,
             },
             f,
@@ -497,9 +470,61 @@ Examples:
     parser.add_argument("--quiet", "-q", action="store_true", help="Reduce output verbosity")
     parser.add_argument("--task", type=str, help="Override task description")
 
+    # Validation options
+    parser.add_argument("--validate", action="store_true", help="Enable validation loop")
+    parser.add_argument("--no-validate", action="store_true", help="Disable validation loop")
+
     return parser.parse_args()
 
 
+def run_validation(story_key: str, args: argparse.Namespace, tier: str = "preflight") -> bool:
+    """Run validation checks.
+
+    Args:
+        story_key: Story identifier
+        args: Command line arguments
+        tier: Which tier to run ("preflight" or "post")
+
+    Returns:
+        True if validation passed, False otherwise
+    """
+    if not HAS_VALIDATION:
+        return True
+
+    validation_enabled = args.validate and not args.no_validate
+    if not validation_enabled:
+        return True
+
+    gates = PREFLIGHT_GATES if tier == "preflight" else POST_COMPLETION_GATES
+    validation_loop = ValidationLoop(
+        gates=gates,
+        config={"auto_fix_enabled": True},
+        story_key=story_key,
+    )
+    context = LoopContext(story_key=story_key, phase=tier)
+
+    if tier == "preflight":
+        print(f"\n{Colors.CYAN}[VALIDATION] Running pre-flight checks...{Colors.END}")
+        report = validation_loop.run_preflight(context)
+    else:
+        print(f"\n{Colors.CYAN}[VALIDATION] Running post-completion checks...{Colors.END}")
+        report = validation_loop.run_post_completion(context)
+
+    if report.passed:
+        print(
+            f"{Colors.GREEN}[PASS] Validation passed ({len(report.gate_results)} gates){Colors.END}"
+        )
+        if report.warnings:
+            for warn in report.warnings:
+                print(f"  {Colors.YELLOW}[WARN] {warn.gate_name}: {warn.message}{Colors.END}")
+        return True
+    else:
+        print(f"{Colors.RED}[FAIL] Validation failed{Colors.END}")
+        for failure in report.failures:
+            print(f"  - {failure.gate_name}: {failure.message}")
+        return tier != "preflight"  # Block on preflight, warn on post
+
+
 def main():
     args = parse_args()
 
@@ -532,6 +557,11 @@ def main():
     print(f"{Colors.BOLD}Story/Task:{Colors.END} {story_key}")
     print(f"{Colors.BOLD}Mode:{Colors.END} ", end="")
 
+    # Run pre-flight validation
+    if not run_validation(story_key, args, "preflight"):
+        print(f"\n{Colors.RED}[BLOCKED] Pre-flight validation failed. Aborting.{Colors.END}")
+        return 1
+
     # Route-only mode
     if args.route_only:
         print("Route Analysis Only")
@@ -579,12 +609,17 @@ def main():
             print("Sequential")
             if not agents:
                 agents = ["SM", "DEV", "REVIEWER"]
-            run_sequential_mode(story_key, task, agents, args)
+            results = run_sequential_mode(story_key, task, agents, args)
+            if results:
+                print(f"  Completed {len(results)} agent(s)")
 
         else:  # auto mode
             print("Auto-Route")
             run_auto_mode(story_key, task, args)
 
+        # Run post-completion validation
+        run_validation(story_key, args, "post")
+
         print(f"\n{Colors.GREEN}{'═' * 60}{Colors.END}")
         print(f"{Colors.GREEN} Collaboration complete!{Colors.END}")
         return 0

package/tooling/scripts/run-collab.sh

@@ -84,25 +84,25 @@ main() {
         show_usage
         exit 0
     fi
-    
+
     # Check for Python
     PYTHON_CMD=$(detect_python)
     if [[ -z "$PYTHON_CMD" ]]; then
         echo -e "${RED}Error: Python 3 not found. Please install Python 3.9+${NC}"
         exit 1
     fi
-    
+
     # Check if Python script exists
     if [[ ! -f "$PYTHON_SCRIPT" ]]; then
         echo -e "${RED}Error: run-collab.py not found at $PYTHON_SCRIPT${NC}"
         exit 1
     fi
-    
+
     # Print banner for non-quiet mode
     if [[ "$*" != *"--quiet"* && "$*" != *"-q"* ]]; then
         print_banner
     fi
-    
+
     # Pass all arguments to Python script
     exec "$PYTHON_CMD" "$PYTHON_SCRIPT" "$@"
 }

package/tooling/scripts/run-story.py

@@ -39,15 +39,32 @@ SCRIPT_DIR = Path(__file__).parent
 # Add lib directory for imports
 sys.path.insert(0, str(SCRIPT_DIR / "lib"))
 
+from platform import IS_WINDOWS, get_platform
+
+from colors import Colors
+
+# Try to import context monitor
+try:
+    from context_monitor import ContextMonitor, StatusLine, get_status_manager
+
+    HAS_CONTEXT_MONITOR = True
+except ImportError:
+    HAS_CONTEXT_MONITOR = False
+
+# Try to import validation loop
+try:
+    from validation_loop import (
+        INTER_PHASE_GATES,
+        POST_COMPLETION_GATES,
+        PREFLIGHT_GATES,
+        LoopContext,
+        ValidationLoop,
+        get_phase_gates,
+    )
 
-def get_platform():
-    """Detect the current platform."""
-    if sys.platform == "win32":
-        return "windows"
-    elif sys.platform == "darwin":
-        return "macos"
-    else:
-        return "linux"
+    HAS_VALIDATION = True
+except ImportError:
+    HAS_VALIDATION = False
 
 
 def run_windows(args):
@@ -121,19 +138,35 @@ Examples:
         "--native", action="store_true", help="Run natively with Python (enables cost tracking)"
     )
     parser.add_argument("--no-monitor", action="store_true", help="Disable live monitoring display")
+    parser.add_argument(
+        "--validate",
+        action="store_true",
+        help="Enable validation loop (pre-flight, inter-phase, post-completion)",
+    )
+    parser.add_argument("--no-validate", action="store_true", help="Disable validation loop")
+    parser.add_argument(
+        "--validation-tier",
+        type=int,
+        choices=[1, 2, 3],
+        help="Run specific validation tier only (1=preflight, 2=inter-phase, 3=post-completion)",
+    )
 
     return parser.parse_args()
 
 
 class NativeRunner:
-    """Native Python runner with cost tracking."""
+    """Native Python runner with cost tracking, context monitoring, and validation."""
 
     def __init__(self, args):
         self.args = args
         self.tracker = None
         self.display = None
+        self.context_monitor = None
+        self.status_line = None
         self.monitor_thread = None
         self.running = False
+        self.validation_loop = None
+        self.validation_context = None
 
         # Import cost modules
         try:
@@ -148,8 +181,145 @@ class NativeRunner:
             print(f"Warning: Cost tracking not available: {e}")
             self.cost_available = False
 
+        # Initialize context monitor if available
+        if HAS_CONTEXT_MONITOR:
+            self.context_monitor = ContextMonitor(
+                story_key=args.story_key,
+                model=args.model,
+                on_threshold=self._on_context_threshold,
+            )
+        else:
+            self.context_monitor = None
+
+        # Initialize validation if available and enabled
+        self.validation_enabled = (
+            HAS_VALIDATION and (args.validate or not args.no_validate) and not args.no_validate
+        )
+        if self.validation_enabled:
+            self._init_validation()
+
+    def _on_context_threshold(self, level, state):
+        """Handle context threshold crossing."""
+        from context_monitor import ContextLevel
+
+        if level == ContextLevel.EMERGENCY:
+            print(f"\n{Colors.BG_RED}{Colors.WHITE} CONTEXT EMERGENCY {Colors.RESET}")
+            print(f"Context at {state.context_usage_percent:.0f}% - compaction imminent!")
+            print("Recommendation: Save checkpoint NOW and clear session.")
+            self._trigger_auto_checkpoint("emergency")
+        elif level == ContextLevel.CRITICAL:
+            print(f"\n{Colors.BOLD_RED}[CRITICAL]{Colors.RESET} Context at {state.context_usage_percent:.0f}%")
+            print("Recommendation: Consider wrapping up and checkpointing soon.")
+            self._trigger_auto_checkpoint("critical")
+        elif level == ContextLevel.WARNING:
+            print(f"\n{Colors.YELLOW}[WARNING]{Colors.RESET} Context at {state.context_usage_percent:.0f}%")
+            print(f"~{state.exchanges_remaining} exchanges remaining before compaction.")
+
+    def _trigger_auto_checkpoint(self, reason: str):
+        """Trigger automatic checkpoint at critical thresholds."""
+        try:
+            # Import checkpoint manager
+            sys.path.insert(0, str(SCRIPT_DIR))
+            from context_checkpoint import ContextCheckpointManager
+
+            manager = ContextCheckpointManager()
+            context_level = self.context_monitor.state.context_usage_ratio if self.context_monitor else 0.0
+            checkpoint_file = manager.create_checkpoint(context_level, reason=reason)
+            print(f"[CHECKPOINT] Saved to: {checkpoint_file.name}")
+
+            if self.context_monitor:
+                self.context_monitor.record_checkpoint()
+        except Exception as e:
+            print(f"{Colors.YELLOW}[WARN] Could not create auto-checkpoint: {e}{Colors.RESET}")
+
+    def _init_validation(self):
+        """Initialize validation loop."""
+        all_gates = PREFLIGHT_GATES + INTER_PHASE_GATES + POST_COMPLETION_GATES
+        self.validation_loop = ValidationLoop(
+            gates=all_gates,
+            config={"auto_fix_enabled": True},
+            story_key=self.args.story_key,
+        )
+        self.validation_context = LoopContext(
+            story_key=self.args.story_key,
+            max_iterations=3,
+        )
+
+    def run_preflight_validation(self) -> bool:
+        """Run pre-flight validation. Returns True if passed."""
+        if not self.validation_enabled or not self.validation_loop:
+            return True
+
+        print("[VALIDATION] Running pre-flight checks...")
+        self.validation_context.phase = "preflight"
+        report = self.validation_loop.run_preflight(self.validation_context)
+
+        if report.passed:
+            print(f"[PASS] Pre-flight validation passed ({len(report.gate_results)} gates)")
+            return True
+        else:
+            print(f"{Colors.RED}[FAIL] Pre-flight validation failed{Colors.RESET}")
+            for failure in report.failures:
+                print(f"  - {failure.gate_name}: {failure.message}")
+            return False
+
+    def run_phase_validation(self, from_phase: str, to_phase: str) -> bool:
+        """Run inter-phase validation. Returns True if passed."""
+        if not self.validation_enabled or not self.validation_loop:
+            return True
+
+        phase_gates = get_phase_gates(from_phase, to_phase)
+        if not phase_gates:
+            return True  # No gates for this transition
+
+        print(f"[VALIDATION] Checking {from_phase} -> {to_phase} transition...")
+        self.validation_context.phase = f"{from_phase}_to_{to_phase}"
+        self.validation_context.from_agent = from_phase
+        self.validation_context.to_agent = to_phase
+
+        # Create a temporary loop with just the phase gates
+        phase_loop = ValidationLoop(
+            gates=phase_gates,
+            config={"auto_fix_enabled": True},
+            story_key=self.args.story_key,
+        )
+        report = phase_loop.run_gates(self.validation_context, tier=2)
+
+        if report.passed:
+            print("[PASS] Phase transition validated")
+            return True
+        else:
+            print(f"{Colors.YELLOW}[WARN] Phase validation issues:{Colors.RESET}")
+            for failure in report.failures:
+                print(f"  - {failure.gate_name}: {failure.message}")
+            # Don't block on inter-phase, just warn
+            return True
+
+    def run_post_validation(self) -> bool:
+        """Run post-completion validation. Returns True if passed."""
+        if not self.validation_enabled or not self.validation_loop:
+            return True
+
+        print("\n[VALIDATION] Running post-completion checks...")
+        self.validation_context.phase = "post-completion"
+        report = self.validation_loop.run_post_completion(self.validation_context)
+
+        if report.passed:
+            print("[PASS] Post-completion validation passed")
+            if report.warnings:
+                print(f"{Colors.YELLOW}[WARN] {len(report.warnings)} warning(s):{Colors.RESET}")
+                for warn in report.warnings:
+                    print(f"  - {warn.gate_name}: {warn.message}")
+            return True
+        else:
+            print(f"{Colors.YELLOW}[WARN] Post-completion validation issues:{Colors.RESET}")
+            for failure in report.failures:
+                print(f"  - {failure.gate_name}: {failure.message}")
+            # Warn but don't fail the overall run
+            return True
+
     def start_tracking(self):
-        """Initialize cost tracking."""
+        """Initialize cost tracking and status line."""
         if not self.cost_available:
             return
 
@@ -158,6 +328,13 @@ class NativeRunner:
         )
         self.display = self.CompactCostDisplay(self.tracker)
 
+        # Create unified status line with context + cost
+        if HAS_CONTEXT_MONITOR and self.context_monitor:
+            self.status_line = StatusLine(
+                context_monitor=self.context_monitor,
+                cost_tracker=self.tracker,
+            )
+
     def start_monitor(self):
         """Start the monitoring display thread."""
         if not self.cost_available or self.args.no_monitor:
@@ -170,7 +347,10 @@ class NativeRunner:
     def _monitor_loop(self):
         """Monitor loop for live display updates."""
         while self.running:
-            if self.tracker:
+            # Use unified status line if available, otherwise fall back to cost display
+            if self.status_line:
+                self.status_line.print(newline=False)
+            elif self.tracker:
                 self.display.print()
             time.sleep(2)
 
@@ -182,7 +362,7 @@ class NativeRunner:
 
     def run_claude(self, agent: str, model: str, prompt: str, timeout: int = 300) -> tuple:
         """Run Claude CLI and capture output."""
-        cli = "claude.cmd" if sys.platform == "win32" else "claude"
+        cli = "claude.cmd" if IS_WINDOWS else "claude"
 
         cmd = [cli, "--print", "--model", model, "-p", prompt]
 
@@ -202,10 +382,14 @@ class NativeRunner:
             output = result.stdout + result.stderr
 
             # Parse token usage from output (if available)
-            if self.tracker:
-                tokens = self._parse_tokens(output)
-                if tokens:
+            tokens = self._parse_tokens(output)
+            if tokens:
+                # Update cost tracker
+                if self.tracker:
                     self.tracker.log_usage(agent, model, tokens[0], tokens[1])
+                # Update context monitor
+                if self.context_monitor:
+                    self.context_monitor.update_from_tokens(tokens[0], tokens[1])
 
             return (result.returncode == 0, output)
 
@@ -243,31 +427,61 @@ class NativeRunner:
         ok, level, msg = self.tracker.check_budget()
 
         if level == "critical":
-            print(f"\n\033[91m{msg}\033[0m")
+            print(f"\n{Colors.RED}{msg}{Colors.RESET}")
         elif level == "warning":
-            print(f"\n\033[93m{msg}\033[0m")
+            print(f"\n{Colors.YELLOW}{msg}{Colors.RESET}")
 
         return ok
 
     def run(self) -> int:
         """Run the story automation."""
-        print(f"Starting story: {self.args.story_key}")
-        print(f"Model: {self.args.model}")
-        print(f"Budget: ${self.args.budget:.2f}")
+        # Print header with status line
+        print(f"{Colors.DIM}{'─' * 70}{Colors.RESET}")
+        print(f"{Colors.BOLD}DEVFLOW STORY RUNNER{Colors.RESET}")
+        print(f"Story: {self.args.story_key} | Model: {self.args.model} | Budget: ${self.args.budget:.2f}")
+        if self.validation_enabled:
+            print("Validation: Enabled")
+        if self.context_monitor:
+            print(f"Context Monitor: Active (window: {self.context_monitor.state.context_window:,} tokens)")
+        print(f"{Colors.DIM}{'─' * 70}{Colors.RESET}")
         print()
 
+        # Run pre-flight validation
+        if not self.run_preflight_validation():
+            print(f"\n{Colors.RED}[BLOCKED] Pre-flight validation failed. Aborting.{Colors.RESET}")
+            return 1
+
         self.start_tracking()
         self.start_monitor()
 
+        # Print initial status line
+        if self.status_line:
+            self.status_line.print()
+
         try:
             # Determine which phases to run
             run_context = self.args.context or (not self.args.develop and not self.args.review)
             run_develop = self.args.develop or (not self.args.context and not self.args.review)
             run_review = self.args.review or (not self.args.context and not self.args.develop)
 
+            # Calculate total phases
+            total_phases = sum([run_context, run_develop, run_review])
+            phases_completed = 0
+
+            # Set initial activity state
+            if self.context_monitor:
+                self.context_monitor.set_current_activity(total_phases=total_phases, phases_completed=0)
+
             # Context phase
             if run_context:
                 print("\n[1/3] Context Phase...")
+                if self.context_monitor:
+                    self.context_monitor.set_current_activity(
+                        agent="SM",
+                        phase="Context Analysis",
+                        task="Preparing development context",
+                        phases_completed=phases_completed,
+                    )
                 success, output = self.run_claude(
                     "SM",
                     "sonnet",
@@ -277,12 +491,27 @@ class NativeRunner:
                     print(f"Context phase failed: {output[:200]}")
                     return 1
 
+                phases_completed += 1
+                if self.context_monitor:
+                    self.context_monitor.set_current_activity(phases_completed=phases_completed)
+
                 if not self.check_budget():
                     return 1
 
+                # Validate context -> dev transition
+                if run_develop:
+                    self.run_phase_validation("CONTEXT", "DEV")
+
             # Development phase
             if run_develop:
                 print("\n[2/3] Development Phase...")
+                if self.context_monitor:
+                    self.context_monitor.set_current_activity(
+                        agent="DEV",
+                        phase="Development",
+                        task="Implementing story",
+                        phases_completed=phases_completed,
+                    )
                 success, output = self.run_claude(
                     "DEV",
                     self.args.model,
@@ -292,12 +521,27 @@ class NativeRunner:
                     print(f"Development phase failed: {output[:200]}")
                     return 1
 
+                phases_completed += 1
+                if self.context_monitor:
+                    self.context_monitor.set_current_activity(phases_completed=phases_completed)
+
                 if not self.check_budget():
                     return 1
 
+                # Validate dev -> review transition
+                if run_review:
+                    self.run_phase_validation("DEV", "REVIEW")
+
             # Review phase
             if run_review and not self.args.context and not self.args.develop:
                 print("\n[3/3] Review Phase...")
+                if self.context_monitor:
+                    self.context_monitor.set_current_activity(
+                        agent="REVIEWER",
+                        phase="Code Review",
+                        task="Reviewing implementation",
+                        phases_completed=phases_completed,
+                    )
                 success, output = self.run_claude(
                     "SM", "sonnet", f"Review the implementation of story {self.args.story_key}"
                 )
@@ -305,8 +549,22 @@ class NativeRunner:
                     print(f"Review phase failed: {output[:200]}")
                     return 1
 
+                phases_completed += 1
+                if self.context_monitor:
+                    self.context_monitor.set_current_activity(phases_completed=phases_completed)
+
+                # Validate review -> complete transition
+                self.run_phase_validation("REVIEW", "COMPLETE")
+
+            # Clear activity when done
+            if self.context_monitor:
+                self.context_monitor.clear_current_activity()
+
             print("\n[OK] Story automation complete!")
 
+            # Run post-completion validation
+            self.run_post_validation()
+
             # Show final costs
             if self.tracker:
                 print()