crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/core/workflow_orchestrator.py

@@ -1,91 +1,103 @@
+"""Workflow Orchestrator for ACB integration.
+
+ACB-powered orchestration layer managing workflow lifecycle, dependency resolution,
+and execution strategies. Supports dual execution modes for gradual migration.
+
+ACB Patterns:
+- MODULE_ID and MODULE_STATUS at module level
+- depends.set() registration after class definition
+- Structured logging with context fields
+- Protocol-based interfaces
+"""
+
+from __future__ import annotations
+
 import asyncio
 import time
 import typing as t
+from contextlib import suppress
+from importlib.metadata import version
 from pathlib import Path
 
-from rich.console import Console
+from acb.config import Config
+from acb.console import Console
+from acb.depends import Inject, depends
+from acb.events import Event, EventHandlerResult
 
 from crackerjack.agents.base import AgentContext, Issue, IssueType, Priority
-from crackerjack.agents.coordinator import AgentCoordinator
-from crackerjack.models.protocols import OptionsProtocol
-from crackerjack.services.debug import (
-    AIAgentDebugger,
-    NoOpDebugger,
-    get_ai_agent_debugger,
-)
-from crackerjack.services.logging import (
-    LoggingContext,
-    get_logger,
-    setup_structured_logging,
-)
-from crackerjack.services.memory_optimizer import get_memory_optimizer, memory_optimized
-from crackerjack.services.performance_benchmarks import PerformanceBenchmarkService
-from crackerjack.services.performance_cache import get_performance_cache
-from crackerjack.services.performance_monitor import (
-    get_performance_monitor,
-    phase_monitor,
-)
-from crackerjack.services.quality_baseline_enhanced import (
-    EnhancedQualityBaselineService,
+from crackerjack.agents.enhanced_coordinator import EnhancedAgentCoordinator
+from crackerjack.events import WorkflowEvent, WorkflowEventBus
+from crackerjack.models.protocols import (
+    DebugServiceProtocol,
+    LoggerProtocol,
+    MemoryOptimizerProtocol,
+    OptionsProtocol,
+    PerformanceBenchmarkProtocol,
+    PerformanceCacheProtocol,
+    PerformanceMonitorProtocol,
+    QualityIntelligenceProtocol,
 )
-from crackerjack.services.quality_intelligence import QualityIntelligenceService
+from crackerjack.services.logging import LoggingContext
+from crackerjack.services.memory_optimizer import memory_optimized
 
 from .phase_coordinator import PhaseCoordinator
-from .session_coordinator import SessionCoordinator
-
-
-def version() -> str:
-    try:
-        import importlib.metadata
-
-        return importlib.metadata.version("crackerjack")
-    except Exception:
-        return "unknown"
+from .session_coordinator import SessionController, SessionCoordinator
+from .workflow import WorkflowPhaseExecutor
 
 
 class WorkflowPipeline:
+    @depends.inject
     def __init__(
         self,
-        console: Console,
-        pkg_path: Path,
-        session: SessionCoordinator,
-        phases: PhaseCoordinator,
+        console: Inject[Console],
+        config: Inject[Config],
+        performance_monitor: Inject[PerformanceMonitorProtocol],
+        memory_optimizer: Inject[MemoryOptimizerProtocol],
+        performance_cache: Inject[PerformanceCacheProtocol],
+        debugger: Inject[DebugServiceProtocol],
+        logger: Inject[LoggerProtocol],
+        session: Inject[SessionCoordinator],
+        phases: Inject[PhaseCoordinator],
+        phase_executor: Inject[WorkflowPhaseExecutor],
+        quality_intelligence: Inject[QualityIntelligenceProtocol] | None = None,
+        performance_benchmarks: Inject[PerformanceBenchmarkProtocol] | None = None,
     ) -> None:
         self.console = console
-        self.pkg_path = pkg_path
+        self.config = config
+        self.pkg_path = config.root_path
         self.session = session
         self.phases = phases
         self._mcp_state_manager: t.Any = None
         self._last_security_audit: t.Any = None
 
-        self.logger = get_logger("crackerjack.pipeline")
-        self._debugger: AIAgentDebugger | NoOpDebugger | None = None
-
-        self._performance_monitor = get_performance_monitor()
-        self._memory_optimizer = get_memory_optimizer()
-        self._cache = get_performance_cache()
-
-        # Initialize quality intelligence for advanced decision making
-        try:
-            quality_baseline = EnhancedQualityBaselineService()
-            self._quality_intelligence = QualityIntelligenceService(quality_baseline)
-        except Exception:
-            # Fallback gracefully if quality intelligence is not available
-            self._quality_intelligence = None
+        # Services injected via ACB DI
+        self._debugger = debugger
+        self._performance_monitor = performance_monitor
+        self._memory_optimizer = memory_optimizer
+        self._cache = performance_cache
+        self._quality_intelligence = quality_intelligence
+        self._performance_benchmarks = performance_benchmarks
+        self.logger = logger
 
-        # Initialize performance benchmarking for workflow analysis
+        # Event bus with graceful fallback
         try:
-            self._performance_benchmarks = PerformanceBenchmarkService(
-                console, pkg_path
+            self._event_bus: WorkflowEventBus | None = depends.get_sync(
+                WorkflowEventBus
             )
-        except Exception:
-            # Fallback gracefully if benchmarking is not available
-            self._performance_benchmarks = None
+        except Exception as e:
+            print(f"WARNING: WorkflowEventBus not available: {type(e).__name__}: {e}")
+            self._event_bus = None
+
+        # Phase executor for workflow execution
+        self._phase_executor = phase_executor
+        self._phase_executor.configure(session, phases, self._event_bus)
+        self._phase_executor._mcp_state_manager = self._mcp_state_manager
+
+        self._session_controller = SessionController(self)
 
     @property
-    def debugger(self) -> AIAgentDebugger | NoOpDebugger:
-        if self._debugger is None:
-            self._debugger = get_ai_agent_debugger()
+    def debugger(self) -> DebugServiceProtocol:
+        """Get debug service (already injected via DI)."""
         return self._debugger
 
     def _should_debug(self) -> bool:
@@ -96,141 +108,515 @@ class WorkflowPipeline:
     @memory_optimized
     async def run_complete_workflow(self, options: OptionsProtocol) -> bool:
         workflow_id = f"workflow_{int(time.time())}"
+        event_context = self._workflow_context(workflow_id, options)
+        start_time = time.time()
 
         self._performance_monitor.start_workflow(workflow_id)
-
         await self._cache.start()
+        await self._publish_event(WorkflowEvent.WORKFLOW_STARTED, event_context)
 
-        with LoggingContext(
-            "workflow_execution",
-            testing=getattr(options, "test", False),
-            skip_hooks=getattr(options, "skip_hooks", False),
-        ):
-            start_time = time.time()
-            self._initialize_workflow_session(options)
-
-            try:
-                success = await self._execute_workflow_with_timing(
-                    options, start_time, workflow_id
+        success = False
+        try:
+            with LoggingContext(
+                "workflow_execution",
+                testing=getattr(options, "test", False),
+                skip_hooks=getattr(options, "skip_hooks", False),
+            ):
+                success = await self._execute_workflow(
+                    options, workflow_id, event_context, start_time
                 )
+            return success
+        except KeyboardInterrupt:
+            return await self._handle_keyboard_interrupt(workflow_id, event_context)
+        except Exception as e:
+            return await self._handle_general_exception(e, workflow_id, event_context)
+        finally:
+            await self._cleanup_workflow_resources()
 
-                workflow_perf = self._performance_monitor.end_workflow(
-                    workflow_id, success
-                )
-                self.logger.info(
-                    f"Workflow performance: {workflow_perf.performance_score: .1f} score, "
-                    f"{workflow_perf.total_duration_seconds: .2f}s duration"
-                )
+    async def _execute_workflow(
+        self,
+        options: OptionsProtocol,
+        workflow_id: str,
+        event_context: dict[str, t.Any],
+        start_time: float,
+    ) -> bool:
+        """Execute the workflow either event-driven or sequentially."""
+        if self._event_bus:
+            return await self._run_event_driven_workflow(
+                options, workflow_id, event_context, start_time
+            )
+        return await self._run_sequential_workflow(
+            options, workflow_id, event_context, start_time
+        )
 
-                return success
+    async def _run_sequential_workflow(
+        self,
+        options: OptionsProtocol,
+        workflow_id: str,
+        event_context: dict[str, t.Any],
+        start_time: float,
+    ) -> bool:
+        """Execute the workflow sequentially."""
+        await self._publish_event(
+            WorkflowEvent.WORKFLOW_SESSION_INITIALIZING,
+            event_context,
+        )
+        self._session_controller.initialize(options)
+        await self._publish_event(
+            WorkflowEvent.WORKFLOW_SESSION_READY,
+            event_context,
+        )
+        success = await self._execute_workflow_with_timing(
+            options, start_time, workflow_id
+        )
+        final_event = (
+            WorkflowEvent.WORKFLOW_COMPLETED
+            if success
+            else WorkflowEvent.WORKFLOW_FAILED
+        )
+        await self._publish_event(
+            final_event,
+            event_context | {"success": success},
+        )
+        self._performance_monitor.end_workflow(workflow_id, success)
+        return success
 
-            except KeyboardInterrupt:
-                self._performance_monitor.end_workflow(workflow_id, False)
-                return self._handle_user_interruption()
+    async def _handle_keyboard_interrupt(
+        self, workflow_id: str, event_context: dict[str, t.Any]
+    ) -> bool:
+        """Handle keyboard interrupt during workflow execution."""
+        self._performance_monitor.end_workflow(workflow_id, False)
+        await self._publish_event(
+            WorkflowEvent.WORKFLOW_INTERRUPTED,
+            event_context,
+        )
+        return self._handle_user_interruption()
 
-            except Exception as e:
-                self._performance_monitor.end_workflow(workflow_id, False)
-                return self._handle_workflow_exception(e)
+    async def _handle_general_exception(
+        self, e: Exception, workflow_id: str, event_context: dict[str, t.Any]
+    ) -> bool:
+        """Handle general exceptions during workflow execution."""
+        self._performance_monitor.end_workflow(workflow_id, False)
+        await self._publish_event(
+            WorkflowEvent.WORKFLOW_FAILED,
+            event_context
+            | {
+                "error": str(e),
+                "error_type": type(e).__name__,
+            },
+        )
+        return self._handle_workflow_exception(e)
 
-            finally:
-                self.session.cleanup_resources()
+    async def _cleanup_workflow_resources(self) -> None:
+        """Clean up workflow resources in the finally block."""
+        self.session.cleanup_resources()
+        self._memory_optimizer.optimize_memory()
+        await self._cache.stop()
 
-                self._memory_optimizer.optimize_memory()
-                await self._cache.stop()
+    def _unsubscribe_all_subscriptions(self, subscriptions: list[str]) -> None:
+        """Unsubscribe from all event subscriptions."""
+        for subscription_id in subscriptions.copy():
+            if self._event_bus:
+                self._event_bus.unsubscribe(subscription_id)
+            subscriptions.remove(subscription_id)
 
-    def _initialize_workflow_session(self, options: OptionsProtocol) -> None:
-        self.session.initialize_session_tracking(options)
-        self.session.track_task("workflow", "Complete crackerjack workflow")
+    async def _finalize_workflow(
+        self,
+        start_time: float,
+        workflow_id: str,
+        success: bool,
+        completion_future: asyncio.Future[bool],
+        subscriptions: list[str],
+        payload: dict[str, t.Any] | None = None,
+    ) -> EventHandlerResult:
+        """Finalize the workflow execution."""
+        if completion_future.done():
+            return EventHandlerResult(success=success)
 
-        self._log_workflow_startup_debug(options)
-        self._configure_session_cleanup(options)
-        self._initialize_zuban_lsp(options)
-        self._configure_hook_manager_lsp(options)
-        self._register_lsp_cleanup_handler(options)
-        self._log_workflow_startup_info(options)
+        self.session.finalize_session(start_time, success)
+        duration = time.time() - start_time
+        self._log_workflow_completion(success, duration)
+        self._log_workflow_completion_debug(success, duration)
 
-    def _log_workflow_startup_debug(self, options: OptionsProtocol) -> None:
-        if not self._should_debug():
-            return
+        workflow_perf = self._performance_monitor.end_workflow(workflow_id, success)
+        self.logger.info(
+            f"Workflow performance: {workflow_perf.performance_score: .1f} score, "
+            f"{workflow_perf.total_duration_seconds: .2f}s duration"
+        )
 
-        self.debugger.log_workflow_phase(
-            "workflow_execution",
-            "started",
-            details={
-                "testing": getattr(options, "test", False),
-                "skip_hooks": getattr(options, "skip_hooks", False),
-                "ai_agent": getattr(options, "ai_agent", False),
-            },
+        await self._generate_performance_benchmark_report(
+            workflow_id, duration, success
         )
 
-    def _configure_session_cleanup(self, options: OptionsProtocol) -> None:
-        if hasattr(options, "cleanup"):
-            self.session.set_cleanup_config(options.cleanup)
+        self._unsubscribe_all_subscriptions(subscriptions)
+        completion_future.set_result(success)
 
-    def _initialize_zuban_lsp(self, options: OptionsProtocol) -> None:
-        """Initialize Zuban LSP server if not disabled."""
-        # Check if LSP is disabled via CLI flag or configuration
-        if getattr(options, "no_zuban_lsp", False):
-            self.logger.debug("Zuban LSP server disabled by --no-zuban-lsp flag")
-            return
+        return EventHandlerResult(success=success)
 
-        # Get configuration from options (will use config system if available)
-        config = getattr(options, "zuban_lsp", None)
-        if config and not config.enabled:
-            self.logger.debug("Zuban LSP server disabled in configuration")
-            return
+    async def _publish_workflow_failure(
+        self,
+        event_context: dict[str, t.Any],
+        stage: str,
+        error: Exception | None = None,
+    ) -> None:
+        """Publish workflow failure event."""
+        payload: dict[str, t.Any] = event_context | {"stage": stage}
+        if error is not None:
+            payload["error"] = str(error)
+            payload["error_type"] = type(error).__name__
 
-        if config and not config.auto_start:
-            self.logger.debug("Zuban LSP server auto-start disabled in configuration")
-            return
+        await self._publish_event(WorkflowEvent.WORKFLOW_FAILED, payload)
 
-        # Check if LSP server is already running to avoid duplicates
-        from crackerjack.services.server_manager import find_zuban_lsp_processes
+    async def _handle_session_ready(
+        self,
+        event: Event,
+        state_flags: dict[str, bool],
+        workflow_id: str,
+        options: OptionsProtocol,
+    ) -> EventHandlerResult:
+        """Handle session ready event."""
+        if state_flags["configuration"]:
+            return EventHandlerResult(success=True)
+        state_flags["configuration"] = True
 
-        existing_processes = find_zuban_lsp_processes()
-        if existing_processes:
-            self.logger.debug(
-                f"Zuban LSP server already running (PID: {existing_processes[0]['pid']})"
+        try:
+            await self._publish_event(
+                WorkflowEvent.CONFIG_PHASE_STARTED,
+                {"workflow_id": workflow_id},
             )
-            return
+            config_success = await asyncio.to_thread(
+                self.phases.run_configuration_phase,
+                options,
+            )
+            await self._publish_event(
+                WorkflowEvent.CONFIG_PHASE_COMPLETED,
+                {
+                    "workflow_id": workflow_id,
+                    "success": config_success,
+                },
+            )
+            if not config_success:
+                await self._publish_workflow_failure(
+                    {"workflow_id": workflow_id}, "configuration"
+                )
+            return EventHandlerResult(success=config_success)
+        except Exception as exc:  # pragma: no cover - defensive
+            await self._publish_workflow_failure(
+                {"workflow_id": workflow_id}, "configuration", exc
+            )
+            return EventHandlerResult(success=False, error_message=str(exc))
+
+    async def _handle_config_completed(
+        self,
+        event: Event,
+        state_flags: dict[str, bool],
+        workflow_id: str,
+        options: OptionsProtocol,
+    ) -> EventHandlerResult:
+        """Handle configuration completed event."""
+        if not event.payload.get("success", False):
+            return EventHandlerResult(success=False)
+        if state_flags["quality"]:
+            return EventHandlerResult(success=True)
+        state_flags["quality"] = True
 
-        # Auto-start LSP server in background
         try:
-            import subprocess
-            import sys
+            await self._publish_event(
+                WorkflowEvent.QUALITY_PHASE_STARTED,
+                {"workflow_id": workflow_id},
+            )
+            quality_success = await self._execute_quality_phase(options, workflow_id)
+            await self._publish_event(
+                WorkflowEvent.QUALITY_PHASE_COMPLETED,
+                {
+                    "workflow_id": workflow_id,
+                    "success": quality_success,
+                },
+            )
+            if not quality_success:
+                await self._publish_workflow_failure(
+                    {"workflow_id": workflow_id}, "quality"
+                )
+            return EventHandlerResult(success=quality_success)
+        except Exception as exc:  # pragma: no cover - defensive
+            await self._publish_workflow_failure(
+                {"workflow_id": workflow_id}, "quality", exc
+            )
+            return EventHandlerResult(success=False, error_message=str(exc))
+
+    async def _handle_quality_completed(
+        self,
+        event: Event,
+        state_flags: dict[str, bool],
+        workflow_id: str,
+        options: OptionsProtocol,
+        publish_requested: bool,
+    ) -> EventHandlerResult:
+        """Handle quality phase completed event."""
+        if not event.payload.get("success", False):
+            return EventHandlerResult(success=False)
+        if state_flags["publishing"]:
+            return EventHandlerResult(success=True)
+        state_flags["publishing"] = True
 
-            # Use configuration values if available, otherwise fallback to CLI options
-            if config:
-                zuban_lsp_port = config.port
-                zuban_lsp_mode = config.mode
+        try:
+            if publish_requested:
+                await self._publish_event(
+                    WorkflowEvent.PUBLISH_PHASE_STARTED,
+                    {"workflow_id": workflow_id},
+                )
+                publishing_success = await self._execute_publishing_workflow(
+                    options, workflow_id
+                )
+                await self._publish_event(
+                    WorkflowEvent.PUBLISH_PHASE_COMPLETED,
+                    {
+                        "workflow_id": workflow_id,
+                        "success": publishing_success,
+                    },
+                )
+                if not publishing_success:
+                    await self._publish_workflow_failure(
+                        {"workflow_id": workflow_id}, "publishing"
+                    )
+                    return EventHandlerResult(success=False)
             else:
-                zuban_lsp_port = getattr(options, "zuban_lsp_port", 8677)
-                zuban_lsp_mode = getattr(options, "zuban_lsp_mode", "stdio")
-
-            cmd = [
-                sys.executable,
-                "-m",
-                "crackerjack",
-                "--start-zuban-lsp",
-                "--zuban-lsp-port",
-                str(zuban_lsp_port),
-                "--zuban-lsp-mode",
-                zuban_lsp_mode,
-            ]
+                await self._publish_event(
+                    WorkflowEvent.PUBLISH_PHASE_COMPLETED,
+                    {
+                        "workflow_id": workflow_id,
+                        "success": True,
+                        "skipped": True,
+                    },
+                )
+            return EventHandlerResult(success=True)
+        except Exception as exc:  # pragma: no cover - defensive
+            await self._publish_workflow_failure(
+                {"workflow_id": workflow_id}, "publishing", exc
+            )
+            return EventHandlerResult(success=False, error_message=str(exc))
+
+    async def _handle_publish_completed(
+        self,
+        event: Event,
+        state_flags: dict[str, bool],
+        workflow_id: str,
+        options: OptionsProtocol,
+        commit_requested: bool,
+        publish_requested: bool,
+        event_context: dict[str, t.Any],
+    ) -> EventHandlerResult:
+        """Handle publishing completed event."""
+        if publish_requested and not event.payload.get("success", False):
+            return EventHandlerResult(success=False)
+        if state_flags["commit"]:
+            return EventHandlerResult(success=True)
+        state_flags["commit"] = True
+
+        try:
+            if commit_requested:
+                await self._publish_event(
+                    WorkflowEvent.COMMIT_PHASE_STARTED,
+                    {"workflow_id": workflow_id},
+                )
+                commit_success = await self._execute_commit_workflow(
+                    options, workflow_id
+                )
+                await self._publish_event(
+                    WorkflowEvent.COMMIT_PHASE_COMPLETED,
+                    {
+                        "workflow_id": workflow_id,
+                        "success": commit_success,
+                    },
+                )
+                if not commit_success:
+                    await self._publish_workflow_failure(
+                        {"workflow_id": workflow_id}, "commit"
+                    )
+                    return EventHandlerResult(success=False)
+            else:
+                await self._publish_event(
+                    WorkflowEvent.COMMIT_PHASE_COMPLETED,
+                    {
+                        "workflow_id": workflow_id,
+                        "success": True,
+                        "skipped": True,
+                    },
+                )
 
-            subprocess.Popen(
-                cmd,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                start_new_session=True,
+            await self._publish_event(
+                WorkflowEvent.WORKFLOW_COMPLETED,
+                event_context | {"success": True},
             )
+            return EventHandlerResult(success=True)
+        except Exception as exc:  # pragma: no cover - defensive
+            await self._publish_workflow_failure(
+                {"workflow_id": workflow_id}, "commit", exc
+            )
+            return EventHandlerResult(success=False, error_message=str(exc))
 
-            self.logger.info(
-                f"Auto-started Zuban LSP server on port {zuban_lsp_port} ({zuban_lsp_mode} mode)"
+    async def _handle_workflow_completed(
+        self,
+        event: Event,
+        start_time: float,
+        workflow_id: str,
+        completion_future: asyncio.Future[bool],
+        subscriptions: list[str],
+    ) -> EventHandlerResult:
+        """Handle workflow completed event."""
+        return await self._finalize_workflow(
+            start_time,
+            workflow_id,
+            True,
+            completion_future,
+            subscriptions,
+            event.payload,
+        )
+
+    async def _handle_workflow_failed(
+        self,
+        event: Event,
+        start_time: float,
+        workflow_id: str,
+        completion_future: asyncio.Future[bool],
+        subscriptions: list[str],
+    ) -> EventHandlerResult:
+        """Handle workflow failed event."""
+        return await self._finalize_workflow(
+            start_time,
+            workflow_id,
+            False,
+            completion_future,
+            subscriptions,
+            event.payload,
+        )
+
+    async def _run_event_driven_workflow(
+        self,
+        options: OptionsProtocol,
+        workflow_id: str,
+        event_context: dict[str, t.Any],
+        start_time: float,
+    ) -> bool:
+        if not self._event_bus:
+            raise RuntimeError("Workflow event bus is not configured.")
+
+        loop = asyncio.get_running_loop()
+        completion_future: asyncio.Future[bool] = loop.create_future()
+        subscriptions: list[str] = []
+
+        publish_requested = bool(
+            getattr(options, "publish", False) or getattr(options, "all", False)
+        )
+        commit_requested = bool(getattr(options, "commit", False))
+
+        state_flags = {
+            "configuration": False,
+            "quality": False,
+            "publishing": False,
+            "commit": False,
+        }
+
+        # Subscribe to events
+        async def on_session_ready(event: Event) -> EventHandlerResult:
+            return await self._handle_session_ready(
+                event, state_flags, workflow_id, options
             )
 
-        except Exception as e:
-            self.logger.warning(f"Failed to auto-start Zuban LSP server: {e}")
+        async def on_config_completed(event: Event) -> EventHandlerResult:
+            return await self._handle_config_completed(
+                event, state_flags, workflow_id, options
+            )
+
+        async def on_quality_completed(event: Event) -> EventHandlerResult:
+            return await self._handle_quality_completed(
+                event, state_flags, workflow_id, options, publish_requested
+            )
+
+        async def on_publish_completed(event: Event) -> EventHandlerResult:
+            return await self._handle_publish_completed(
+                event,
+                state_flags,
+                workflow_id,
+                options,
+                commit_requested,
+                publish_requested,
+                event_context,
+            )
+
+        async def on_workflow_completed(event: Event) -> EventHandlerResult:
+            return await self._handle_workflow_completed(
+                event, start_time, workflow_id, completion_future, subscriptions
+            )
+
+        async def on_workflow_failed(event: Event) -> EventHandlerResult:
+            return await self._handle_workflow_failed(
+                event, start_time, workflow_id, completion_future, subscriptions
+            )
+
+        subscriptions.extend(
+            (
+                self._event_bus.subscribe(
+                    WorkflowEvent.WORKFLOW_SESSION_READY,
+                    on_session_ready,
+                ),
+                self._event_bus.subscribe(
+                    WorkflowEvent.CONFIG_PHASE_COMPLETED,
+                    on_config_completed,
+                ),
+                self._event_bus.subscribe(
+                    WorkflowEvent.QUALITY_PHASE_COMPLETED,
+                    on_quality_completed,
+                ),
+                self._event_bus.subscribe(
+                    WorkflowEvent.PUBLISH_PHASE_COMPLETED,
+                    on_publish_completed,
+                ),
+                self._event_bus.subscribe(
+                    WorkflowEvent.WORKFLOW_COMPLETED,
+                    on_workflow_completed,
+                ),
+                self._event_bus.subscribe(
+                    WorkflowEvent.WORKFLOW_FAILED,
+                    on_workflow_failed,
+                ),
+            )
+        )
+
+        try:
+            await self._publish_event(
+                WorkflowEvent.WORKFLOW_SESSION_INITIALIZING,
+                event_context,
+            )
+            self._session_controller.initialize(options)
+            await self._publish_event(
+                WorkflowEvent.WORKFLOW_SESSION_READY,
+                event_context,
+            )
+        except Exception as exc:  # pragma: no cover - defensive
+            await self._publish_workflow_failure(
+                event_context, "session_initialization", exc
+            )
+            await self._finalize_workflow(
+                start_time, workflow_id, False, completion_future, subscriptions
+            )
+            return False
+
+        return await completion_future
+
+    def _log_workflow_startup_debug(self, options: OptionsProtocol) -> None:
+        if not self._should_debug():
+            return
+
+        self.debugger.log_workflow_phase(
+            "workflow_execution",
+            "started",
+            details={
+                "testing": getattr(options, "test", False),
+                "skip_hooks": getattr(options, "skip_hooks", False),
+                "ai_agent": getattr(options, "ai_agent", False),
+            },
+        )
 
     def _log_zuban_lsp_status(self) -> None:
         """Display current Zuban LSP server status during workflow startup."""
@@ -251,54 +637,6 @@ class WorkflowPipeline:
         except Exception as e:
             self.logger.debug(f"Failed to check Zuban LSP status: {e}")
 
-    def _configure_hook_manager_lsp(self, options: OptionsProtocol) -> None:
-        """Configure hook manager with LSP optimization settings."""
-        # Check if LSP hooks are enabled
-        enable_lsp_hooks = getattr(options, "enable_lsp_hooks", False)
-
-        # Configure the hook manager
-        hook_manager = self.phases.hook_manager
-        if hasattr(hook_manager, "configure_lsp_optimization"):
-            hook_manager.configure_lsp_optimization(enable_lsp_hooks)
-
-            if enable_lsp_hooks and not getattr(options, "no_zuban_lsp", False):
-                self.console.print(
-                    "🔍 LSP-optimized hook execution enabled for faster type checking",
-                    style="blue",
-                )
-
-    def _register_lsp_cleanup_handler(self, options: OptionsProtocol) -> None:
-        """Register cleanup handler to stop LSP server when workflow completes."""
-        # Get configuration to check if we should handle LSP cleanup
-        config = getattr(options, "zuban_lsp", None)
-        if config and not config.enabled:
-            return
-
-        if getattr(options, "no_zuban_lsp", False):
-            return
-
-        def cleanup_lsp_server() -> None:
-            """Cleanup function to gracefully stop LSP server if it was auto-started."""
-            try:
-                from crackerjack.services.server_manager import (
-                    find_zuban_lsp_processes,
-                    stop_process,
-                )
-
-                lsp_processes = find_zuban_lsp_processes()
-                if lsp_processes:
-                    for proc in lsp_processes:
-                        self.logger.debug(
-                            f"Stopping auto-started Zuban LSP server (PID: {proc['pid']})"
-                        )
-                        stop_process(proc["pid"])
-
-            except Exception as e:
-                self.logger.debug(f"Error during LSP cleanup: {e}")
-
-        # Register the cleanup handler with the session
-        self.session.register_cleanup(cleanup_lsp_server)
-
     def _log_workflow_startup_info(self, options: OptionsProtocol) -> None:
         self.logger.info(
             "Starting complete workflow execution",
@@ -313,7 +651,9 @@ class WorkflowPipeline:
     async def _execute_workflow_with_timing(
         self, options: OptionsProtocol, start_time: float, workflow_id: str
     ) -> bool:
-        success = await self._execute_workflow_phases(options, workflow_id)
+        success = await self._phase_executor._execute_workflow_phases(
+            options, workflow_id
+        )
         self.session.finalize_session(start_time, success)
 
         duration = time.time() - start_time
@@ -351,36 +691,9 @@ class WorkflowPipeline:
             return
 
         try:
-            # Gather performance metrics from the workflow execution
-            {
-                "workflow_id": workflow_id,
-                "total_duration": duration,
-                "success": success,
-                "cache_metrics": self._cache.get_stats() if self._cache else {},
-                "memory_metrics": self._memory_optimizer.get_stats()
-                if hasattr(self._memory_optimizer, "get_stats")
-                else {},
-            }
-
-            # Generate benchmark comparison
+            self._gather_performance_metrics(workflow_id, duration, success)
             benchmark_results = await self._performance_benchmarks.run_benchmark_suite()
-
-            # Display compact performance summary
-            if benchmark_results:
-                self.console.print("\n[cyan]📊 Performance Benchmark Summary[/cyan]")
-                self.console.print(f"Workflow Duration: [bold]{duration:.2f}s[/bold]")
-
-                # Show key performance improvements if available
-                for result in benchmark_results.results[:3]:  # Top 3 results
-                    if result.time_improvement_percentage > 0:
-                        self.console.print(
-                            f"[green]⚡[/green] {result.test_name}: {result.time_improvement_percentage:.1f}% faster"
-                        )
-
-                    if result.cache_hit_ratio > 0:
-                        self.console.print(
-                            f"[blue]🎯[/blue] Cache efficiency: {result.cache_hit_ratio:.0%}"
-                        )
+            self._display_benchmark_results(benchmark_results, duration)
 
         except Exception as e:
             self.console.print(
@@ -390,6 +703,53 @@ class WorkflowPipeline:
         if self.debugger.enabled:
             self.debugger.print_debug_summary()
 
+    def _gather_performance_metrics(
+        self, workflow_id: str, duration: float, success: bool
+    ) -> dict[str, t.Any]:
+        """Gather performance metrics from workflow execution."""
+        return {
+            "workflow_id": workflow_id,
+            "total_duration": duration,
+            "success": success,
+            "cache_metrics": self._cache.get_stats() if self._cache else {},
+            "memory_metrics": self._memory_optimizer.get_stats()
+            if hasattr(self._memory_optimizer, "get_stats")
+            else {},
+        }
+
+    def _display_benchmark_results(
+        self, benchmark_results: t.Any, duration: float
+    ) -> None:
+        """Display compact performance summary."""
+        if not benchmark_results:
+            return
+
+        self.console.print("\n[cyan]📊 Performance Benchmark Summary[/cyan]")
+        self.console.print(f"Workflow Duration: [bold]{duration:.2f}s[/bold]")
+
+        self._show_performance_improvements(benchmark_results)
+
+    def _show_performance_improvements(self, benchmark_results: t.Any) -> None:
+        """Show key performance improvements from benchmark results."""
+        for result in benchmark_results.results[:3]:  # Top 3 results
+            self._display_time_improvement(result)
+            self._display_cache_efficiency(result)
+
+    def _display_time_improvement(self, result: t.Any) -> None:
+        """Display time improvement percentage if available."""
+        if result.time_improvement_percentage > 0:
+            self.console.print(
+                f"[green]⚡[/green] {result.test_name}:"
+                f" {result.time_improvement_percentage:.1f}% faster"
+            )
+
+    def _display_cache_efficiency(self, result: t.Any) -> None:
+        """Display cache hit ratio if available."""
+        if result.cache_hit_ratio > 0:
+            self.console.print(
+                f"[blue]🎯[/blue] Cache efficiency: {result.cache_hit_ratio:.0%}"
+            )
+
     def _handle_user_interruption(self) -> bool:
         self.console.print("Interrupted by user")
         self.session.fail_task("workflow", "Interrupted by user")
@@ -406,45 +766,6 @@ class WorkflowPipeline:
         )
         return False
 
-    async def _execute_workflow_phases(
-        self, options: OptionsProtocol, workflow_id: str
-    ) -> bool:
-        success = True
-
-        with phase_monitor(workflow_id, "configuration"):
-            config_success = self.phases.run_configuration_phase(options)
-            success = success and config_success
-
-        quality_success = await self._execute_quality_phase(options, workflow_id)
-        success = success and quality_success
-
-        # If quality phase failed and we're in publishing mode, stop here
-        if not quality_success and self._is_publishing_workflow(options):
-            return False
-
-        # Execute publishing workflow if requested
-        publishing_success = await self._execute_publishing_workflow(
-            options, workflow_id
-        )
-        if not publishing_success:
-            success = False
-
-        # Execute commit workflow independently if requested
-        # Note: Commit workflow runs regardless of publish success to ensure
-        # version bump changes are always committed when requested
-        commit_success = await self._execute_commit_workflow(options, workflow_id)
-        if not commit_success:
-            success = False
-
-        # Only fail the overall workflow if publishing was explicitly requested and failed
-        if not publishing_success and (options.publish or options.all):
-            self.console.print(
-                "[red]❌ Publishing failed - overall workflow marked as failed[/red]"
-            )
-            return False
-
-        return success
-
     def _handle_quality_phase_result(
         self, success: bool, quality_success: bool, options: OptionsProtocol
     ) -> bool:
@@ -469,222 +790,14 @@ class WorkflowPipeline:
             return False
         return success
 
-    def _is_publishing_workflow(self, options: OptionsProtocol) -> bool:
-        return bool(options.publish or options.all)
-
-    async def _execute_publishing_workflow(
-        self, options: OptionsProtocol, workflow_id: str
-    ) -> bool:
-        if not options.publish and not options.all:
-            return True
-
-        with phase_monitor(workflow_id, "publishing"):
-            if not self.phases.run_publishing_phase(options):
-                self.session.fail_task("workflow", "Publishing failed")
-                return False
-        return True
-
-    async def _execute_commit_workflow(
-        self, options: OptionsProtocol, workflow_id: str
-    ) -> bool:
-        if not options.commit:
-            return True
-
-        with phase_monitor(workflow_id, "commit"):
-            if not self.phases.run_commit_phase(options):
-                return False
-        return True
-
-    async def _execute_quality_phase(
-        self, options: OptionsProtocol, workflow_id: str
-    ) -> bool:
-        # Use quality intelligence to make informed decisions about quality phase
-        if self._quality_intelligence:
-            quality_decision = await self._make_quality_intelligence_decision(options)
-            self.console.print(
-                f"[dim]🧠 Quality Intelligence: {quality_decision}[/dim]"
-            )
-
-        if hasattr(options, "fast") and options.fast:
-            return await self._run_fast_hooks_phase_monitored(options, workflow_id)
-        if hasattr(options, "comp") and options.comp:
-            return await self._run_comprehensive_hooks_phase_monitored(
-                options, workflow_id
-            )
-        if getattr(options, "test", False):
-            return await self._execute_test_workflow(options, workflow_id)
-        return await self._execute_standard_hooks_workflow_monitored(
-            options, workflow_id
-        )
-
-    async def _make_quality_intelligence_decision(
-        self, options: OptionsProtocol
-    ) -> str:
-        """Use quality intelligence to make informed decisions about workflow execution."""
-        try:
-            if not self._quality_intelligence:
-                return "Quality intelligence not available"
-
-            # Analyze recent quality trends and anomalies
-            anomalies = self._quality_intelligence.detect_anomalies()
-            patterns = self._quality_intelligence.identify_patterns()
-
-            # Make intelligent recommendations based on current state
-            recommendations = []
-            if anomalies:
-                high_severity_anomalies = [
-                    a for a in anomalies if a.severity.name in ("CRITICAL", "HIGH")
-                ]
-                if high_severity_anomalies:
-                    recommendations.append(
-                        "comprehensive analysis recommended due to quality anomalies"
-                    )
-                else:
-                    recommendations.append("standard quality checks sufficient")
-
-            if patterns:
-                improving_patterns = [
-                    p for p in patterns if p.trend_direction.name == "IMPROVING"
-                ]
-                if improving_patterns:
-                    recommendations.append("quality trending upward")
-                else:
-                    recommendations.append("quality monitoring active")
-
-            if not recommendations:
-                recommendations.append("baseline quality analysis active")
-
-            return "; ".join(recommendations)
-
-        except Exception as e:
-            return f"Quality intelligence analysis failed: {str(e)[:50]}..."
-
-    async def _execute_test_workflow(
-        self, options: OptionsProtocol, workflow_id: str
-    ) -> bool:
-        iteration = self._start_iteration_tracking(options)
-
-        if not await self._execute_initial_phases(options, workflow_id, iteration):
-            return False
-
-        (
-            testing_passed,
-            comprehensive_passed,
-        ) = await self._run_main_quality_phases_async(options, workflow_id)
-
-        return await self._handle_workflow_completion(
-            options, iteration, testing_passed, comprehensive_passed, workflow_id
-        )
-
-    async def _execute_initial_phases(
-        self, options: OptionsProtocol, workflow_id: str, iteration: int
-    ) -> bool:
-        with phase_monitor(workflow_id, "fast_hooks") as monitor:
-            if not await self._run_initial_fast_hooks_async(
-                options, iteration, monitor
-            ):
-                return False
-
-        return self._execute_optional_cleaning_phase(options)
-
-    def _execute_optional_cleaning_phase(self, options: OptionsProtocol) -> bool:
-        if not getattr(options, "clean", False):
-            return True
-
-        if not self._run_code_cleaning_phase(options):
-            return False
-
-        if not self._run_post_cleaning_fast_hooks(options):
-            return False
-
-        self._mark_code_cleaning_complete()
-        return True
-
-    async def _handle_workflow_completion(
-        self,
-        options: OptionsProtocol,
-        iteration: int,
-        testing_passed: bool,
-        comprehensive_passed: bool,
-        workflow_id: str = "unknown",
-    ) -> bool:
-        if options.ai_agent:
-            return await self._handle_ai_agent_workflow(
-                options, iteration, testing_passed, comprehensive_passed, workflow_id
-            )
-
-        return await self._handle_standard_workflow(
-            options, iteration, testing_passed, comprehensive_passed
-        )
-
-    def _start_iteration_tracking(self, options: OptionsProtocol) -> int:
-        iteration = 1
-        if options.ai_agent and self._should_debug():
-            self.debugger.log_iteration_start(iteration)
-        return iteration
-
     def _run_initial_fast_hooks(self, options: OptionsProtocol, iteration: int) -> bool:
-        fast_hooks_passed = self._run_fast_hooks_phase(options)
+        fast_hooks_passed = self._phase_executor._run_fast_hooks_phase(options)
         if not fast_hooks_passed:
             if options.ai_agent and self._should_debug():
                 self.debugger.log_iteration_end(iteration, False)
             return False
         return True
 
-    async def _run_main_quality_phases_async(
-        self, options: OptionsProtocol, workflow_id: str
-    ) -> tuple[bool, bool]:
-        testing_task = asyncio.create_task(
-            self._run_testing_phase_async(options, workflow_id)
-        )
-        comprehensive_task = asyncio.create_task(
-            self._run_comprehensive_hooks_phase_monitored(options, workflow_id)
-        )
-
-        results = await asyncio.gather(
-            testing_task, comprehensive_task, return_exceptions=True
-        )
-
-        testing_result, comprehensive_result = results
-
-        if isinstance(testing_result, Exception):
-            self.logger.error(f"Testing phase failed with exception: {testing_result}")
-            testing_passed = False
-        else:
-            testing_passed = bool(testing_result)
-
-        if isinstance(comprehensive_result, Exception):
-            self.logger.error(
-                f"Comprehensive hooks failed with exception: {comprehensive_result}"
-            )
-            comprehensive_passed = False
-        else:
-            comprehensive_passed = bool(comprehensive_result)
-
-        return testing_passed, comprehensive_passed
-
-    async def _handle_ai_agent_workflow(
-        self,
-        options: OptionsProtocol,
-        iteration: int,
-        testing_passed: bool,
-        comprehensive_passed: bool,
-        workflow_id: str = "unknown",
-    ) -> bool:
-        if not await self._process_security_gates(options):
-            return False
-
-        needs_ai_fixing = self._determine_ai_fixing_needed(
-            testing_passed, comprehensive_passed, bool(options.publish or options.all)
-        )
-
-        if needs_ai_fixing:
-            return await self._execute_ai_fixing_workflow(options, iteration)
-
-        return self._finalize_ai_workflow_success(
-            options, iteration, testing_passed, comprehensive_passed
-        )
-
     async def _process_security_gates(self, options: OptionsProtocol) -> bool:
         publishing_requested, security_blocks = (
             self._check_security_gates_for_publishing(options)
@@ -698,240 +811,180 @@ class WorkflowPipeline:
         )
         return security_fix_result
 
-    async def _execute_ai_fixing_workflow(
-        self, options: OptionsProtocol, iteration: int
-    ) -> bool:
-        success = await self._run_ai_agent_fixing_phase(options)
-        if self._should_debug():
-            self.debugger.log_iteration_end(iteration, success)
-        return success
-
-    def _finalize_ai_workflow_success(
-        self,
-        options: OptionsProtocol,
-        iteration: int,
-        testing_passed: bool,
-        comprehensive_passed: bool,
-    ) -> bool:
-        publishing_requested = bool(options.publish or options.all)
-
-        final_success = self._determine_workflow_success(
-            testing_passed, comprehensive_passed, publishing_requested
-        )
-
-        self._show_partial_success_warning_if_needed(
-            publishing_requested, final_success, testing_passed, comprehensive_passed
-        )
-
-        if self._should_debug():
-            self.debugger.log_iteration_end(iteration, final_success)
-
-        return final_success
-
-    def _show_partial_success_warning_if_needed(
-        self,
-        publishing_requested: bool,
-        final_success: bool,
-        testing_passed: bool,
-        comprehensive_passed: bool,
-    ) -> None:
-        should_show_warning = (
-            publishing_requested
-            and final_success
-            and not (testing_passed and comprehensive_passed)
-        )
-
-        if should_show_warning:
-            self._show_security_audit_warning()
+    def _execute_standard_hooks_workflow(self, options: OptionsProtocol) -> bool:
+        self._phase_executor._update_hooks_status_running()
 
-    async def _handle_standard_workflow(
-        self,
-        options: OptionsProtocol,
-        iteration: int,
-        testing_passed: bool,
-        comprehensive_passed: bool,
-    ) -> bool:
-        publishing_requested, security_blocks = (
-            self._check_security_gates_for_publishing(options)
-        )
+        if not self._execute_fast_hooks_workflow(options):
+            self._phase_executor._handle_hooks_completion(False)
+            return False
 
-        if publishing_requested and security_blocks:
-            return await self._handle_security_gate_failure(options)
+        if not self._execute_cleaning_workflow_if_needed(options):
+            self._phase_executor._handle_hooks_completion(False)
+            return False
 
-        success = self._determine_workflow_success(
-            testing_passed,
-            comprehensive_passed,
-            publishing_requested,
+        comprehensive_success = self._phase_executor._run_comprehensive_hooks_phase(
+            options
         )
+        self._phase_executor._handle_hooks_completion(comprehensive_success)
 
-        if (
-            publishing_requested
-            and success
-            and not (testing_passed and comprehensive_passed)
-        ):
-            self._show_security_audit_warning()
-        elif publishing_requested and not success:
-            self.console.print(
-                "[red]❌ Quality checks failed - cannot proceed to publishing[/red]"
-            )
+        return comprehensive_success
 
-        if not success and getattr(options, "verbose", False):
-            self._show_verbose_failure_details(testing_passed, comprehensive_passed)
+    def _execute_fast_hooks_workflow(self, options: OptionsProtocol) -> bool:
+        """Execute fast hooks phase."""
+        return self._phase_executor._run_fast_hooks_phase(options)
 
-        if options.ai_agent and self._should_debug():
-            self.debugger.log_iteration_end(iteration, success)
-        return success
+    def _execute_cleaning_workflow_if_needed(self, options: OptionsProtocol) -> bool:
+        """Execute cleaning workflow if requested."""
+        if not getattr(options, "clean", False):
+            return True
 
-    def _run_fast_hooks_phase(self, options: OptionsProtocol) -> bool:
-        self._update_mcp_status("fast", "running")
+        if not self._phase_executor._run_code_cleaning_phase(options):
+            return False
 
-        if not self.phases.run_fast_hooks_only(options):
-            self.session.fail_task("workflow", "Fast hooks failed")
-            self._update_mcp_status("fast", "failed")
+        if not self._phase_executor._run_post_cleaning_fast_hooks(options):
             return False
 
-        self._update_mcp_status("fast", "completed")
+        self._phase_executor._mark_code_cleaning_complete()
         return True
 
-    def _run_testing_phase(self, options: OptionsProtocol) -> bool:
-        self._update_mcp_status("tests", "running")
-
-        success = self.phases.run_testing_phase(options)
-        if not success:
-            self.session.fail_task("workflow", "Testing failed")
-            self._handle_test_failures()
-            self._update_mcp_status("tests", "failed")
-
-        else:
-            self._update_mcp_status("tests", "completed")
-
-        return success
-
-    def _run_comprehensive_hooks_phase(self, options: OptionsProtocol) -> bool:
-        self._update_mcp_status("comprehensive", "running")
-
-        success = self.phases.run_comprehensive_hooks_only(options)
-        if not success:
-            self.session.fail_task("comprehensive_hooks", "Comprehensive hooks failed")
-            self._update_mcp_status("comprehensive", "failed")
-
-        else:
-            self._update_mcp_status("comprehensive", "completed")
-
-        return success
-
-    def _update_mcp_status(self, stage: str, status: str) -> None:
-        if hasattr(self, "_mcp_state_manager") and self._mcp_state_manager:
-            self._mcp_state_manager.update_stage_status(stage, status)
-
-    def _run_code_cleaning_phase(self, options: OptionsProtocol) -> bool:
-        self.console.print("\n[bold blue]🧹 Running Code Cleaning Phase...[/bold blue]")
-
-        success = self.phases.run_cleaning_phase(options)
-        if success:
-            self.console.print("[green]✅ Code cleaning completed successfully[/green]")
-        else:
-            self.console.print("[red]❌ Code cleaning failed[/red]")
-            self.session.fail_task("workflow", "Code cleaning phase failed")
-
-        return success
-
-    def _run_post_cleaning_fast_hooks(self, options: OptionsProtocol) -> bool:
-        self.console.print(
-            "\n[bold cyan]🔍 Running Post-Cleaning Fast Hooks Sanity Check...[/bold cyan]"
+    def _is_publishing_workflow(self, options: OptionsProtocol) -> bool:
+        """Check if this is a publishing workflow."""
+        return bool(
+            getattr(options, "publish", False) or getattr(options, "all", False)
         )
 
-        success = self._run_fast_hooks_phase(options)
-        if success:
-            self.console.print("[green]✅ Post-cleaning sanity check passed[/green]")
-        else:
-            self.console.print("[red]❌ Post-cleaning sanity check failed[/red]")
-            self.session.fail_task("workflow", "Post-cleaning fast hooks failed")
-
-        return success
-
-    def _has_code_cleaning_run(self) -> bool:
-        return getattr(self, "_code_cleaning_complete", False)
-
-    def _mark_code_cleaning_complete(self) -> None:
-        self._code_cleaning_complete = True
-
-    def _handle_test_failures(self) -> None:
-        if not (hasattr(self, "_mcp_state_manager") and self._mcp_state_manager):
-            return
-
-        test_manager = self.phases.test_manager
-        if not hasattr(test_manager, "get_test_failures"):
-            return
-
-        failures = test_manager.get_test_failures()
-
-        if self._should_debug():
-            self.debugger.log_test_failures(len(failures))
-
-        from crackerjack.mcp.state import Issue, Priority
+    def _update_mcp_status(self, phase: str, status: str) -> None:
+        """Update MCP (Model Context Protocol) status."""
+        # Check if _mcp_state_manager exists and is not None
+        mcp_state_manager = getattr(self, "_mcp_state_manager", None)
+        if mcp_state_manager:
+            try:
+                mcp_state_manager.update_status(phase, status)
+            except (AttributeError, TypeError, RuntimeError) as e:
+                # If MCP is not available or fails, continue without error
+                self.logger.debug(f"MCP status update failed: {e}")
 
-        for i, failure in enumerate(failures[:10]):
-            issue = Issue(
-                id=f"test_failure_{i}",
-                type="test_failure",
-                message=failure.strip(),
-                file_path="tests /",
-                priority=Priority.HIGH,
-                stage="tests",
-                auto_fixable=False,
-            )
-            self._mcp_state_manager.add_issue(issue)
+    async def _execute_quality_phase(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
+        """Execute the quality phase of the workflow."""
+        try:
+            # Check if this is a publishing workflow
+            is_publishing = self._is_publishing_workflow(options)
+
+            # Run fast hooks phase first
+            fast_success = self.phases.run_fast_hooks_only(options)
+            if not fast_success and is_publishing:
+                return False  # For publishing workflows, fast hook failures should stop execution
+
+            # Run comprehensive hooks phase
+            comprehensive_success = self.phases.run_comprehensive_hooks_only(options)
+            if not comprehensive_success and is_publishing:
+                return False  # For publishing workflows, comprehensive hook failures should stop execution
+
+            # Both fast and comprehensive hooks must pass for success
+            quality_success = fast_success and comprehensive_success
+
+            # Run testing phase if requested
+            if getattr(options, "test", False):
+                testing_success = self.phases.run_testing_phase(options)
+                if not testing_success and is_publishing:
+                    return False  # For publishing workflows, test failures should stop execution
+                # For non-publishing workflows, testing failures should factor into overall success too
+                quality_success = quality_success and testing_success
+
+            return quality_success
+        except Exception as e:
+            self.logger.error(f"Quality phase execution failed: {e}")
+            return False
 
-    def _execute_standard_hooks_workflow(self, options: OptionsProtocol) -> bool:
-        self._update_hooks_status_running()
+    async def _execute_publishing_workflow(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
+        """Execute the publishing workflow phase."""
+        try:
+            # Run publishing phase
+            publishing_success = self.phases.run_publishing_phase(options)
+            return publishing_success
+        except Exception as e:
+            self.logger.error(f"Publishing workflow execution failed: {e}")
+            return False
 
-        fast_hooks_success = self._run_fast_hooks_phase(options)
-        if not fast_hooks_success:
-            self._handle_hooks_completion(False)
+    async def _execute_commit_workflow(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
+        """Execute the commit workflow phase."""
+        try:
+            # Run commit phase
+            commit_success = self.phases.run_commit_phase(options)
+            return commit_success
+        except Exception as e:
+            self.logger.error(f"Commit workflow execution failed: {e}")
             return False
 
-        if getattr(options, "clean", False):
-            if not self._run_code_cleaning_phase(options):
-                self._handle_hooks_completion(False)
-                return False
+    def _has_code_cleaning_run(self) -> bool:
+        """Check if code cleaning has already run in this session."""
+        # Check session metadata or a dedicated flag
+        if (
+            self.session.session_tracker
+            and "code_cleaning_completed" in self.session.session_tracker.metadata
+        ):
+            return bool(
+                self.session.session_tracker.metadata["code_cleaning_completed"]
+            )
+        return False
 
-            if not self._run_post_cleaning_fast_hooks(options):
-                self._handle_hooks_completion(False)
-                return False
-            self._mark_code_cleaning_complete()
+    def _mark_code_cleaning_complete(self) -> None:
+        """Mark that code cleaning has been completed."""
+        if self.session.session_tracker:
+            self.session.session_tracker.metadata["code_cleaning_completed"] = True
 
-        comprehensive_success = self._run_comprehensive_hooks_phase(options)
+    def _run_code_cleaning_phase(self, options: OptionsProtocol) -> bool:
+        """Execute code cleaning phase - wrapper for ACB workflow compatibility."""
+        result: bool = self.phases.run_cleaning_phase(options)  # type: ignore[arg-type,assignment]
+        return result
 
-        hooks_success = fast_hooks_success and comprehensive_success
-        self._handle_hooks_completion(hooks_success)
+    def _run_post_cleaning_fast_hooks(self, options: OptionsProtocol) -> bool:
+        """Run fast hooks after code cleaning phase."""
+        result: bool = self.phases.run_fast_hooks_only(options)  # type: ignore[arg-type,assignment]
+        return result
 
-        return hooks_success
+    def _run_fast_hooks_phase(self, options: OptionsProtocol) -> bool:
+        """Execute fast hooks phase - wrapper for ACB workflow compatibility."""
+        result: bool = self.phases.run_fast_hooks_only(options)  # type: ignore[arg-type,assignment]
+        return result
 
-    def _update_hooks_status_running(self) -> None:
-        if self._has_mcp_state_manager():
-            self._mcp_state_manager.update_stage_status("fast", "running")
-            self._mcp_state_manager.update_stage_status("comprehensive", "running")
+    def _run_comprehensive_hooks_phase(self, options: OptionsProtocol) -> bool:
+        """Execute comprehensive hooks phase - wrapper for ACB workflow compatibility."""
+        result: bool = self.phases.run_comprehensive_hooks_only(options)  # type: ignore[arg-type,assignment]
+        return result
 
-    def _handle_hooks_completion(self, hooks_success: bool) -> None:
-        if not hooks_success:
-            self.session.fail_task("workflow", "Hooks failed")
-            self._update_hooks_status_failed()
-        else:
-            self._update_hooks_status_completed()
+    def _run_testing_phase(self, options: OptionsProtocol) -> bool:
+        """Execute testing phase - wrapper for ACB workflow compatibility."""
+        result: bool = self.phases.run_testing_phase(options)  # type: ignore[arg-type,assignment]
+        return result
+
+    def _configure_session_cleanup(self, options: OptionsProtocol) -> None:
+        """Configure session cleanup handlers."""
+        # Add any necessary session cleanup configuration here
+        self.session.register_cleanup(self._cleanup_workflow_resources)
+        if hasattr(self, "_mcp_state_manager") and self._mcp_state_manager:
+            self.session.register_cleanup(self._mcp_state_manager.cleanup)
 
-    def _has_mcp_state_manager(self) -> bool:
-        return hasattr(self, "_mcp_state_manager") and self._mcp_state_manager
+    def _initialize_zuban_lsp(self, options: OptionsProtocol) -> None:
+        """Initialize Zuban LSP server if needed."""
+        # Placeholder implementation - actual LSP initialization would go here
+        pass
 
-    def _update_hooks_status_failed(self) -> None:
-        if self._has_mcp_state_manager():
-            self._mcp_state_manager.update_stage_status("fast", "failed")
-            self._mcp_state_manager.update_stage_status("comprehensive", "failed")
+    def _configure_hook_manager_lsp(self, options: OptionsProtocol) -> None:
+        """Configure hook manager LSP settings."""
+        # Placeholder implementation - actual hook manager LSP configuration would go here
+        pass
 
-    def _update_hooks_status_completed(self) -> None:
-        if self._has_mcp_state_manager():
-            self._mcp_state_manager.update_stage_status("fast", "completed")
-            self._mcp_state_manager.update_stage_status("comprehensive", "completed")
+    def _register_lsp_cleanup_handler(self, options: OptionsProtocol) -> None:
+        """Register LSP cleanup handler."""
+        # Placeholder implementation - actual LSP cleanup handler would go here
+        pass
 
     async def _run_ai_agent_fixing_phase(self, options: OptionsProtocol) -> bool:
         self._initialize_ai_fixing_phase(options)
@@ -952,6 +1005,12 @@ class WorkflowPipeline:
     def _initialize_ai_fixing_phase(self, options: OptionsProtocol) -> None:
         self._update_mcp_status("ai_fixing", "running")
         self.logger.info("Starting AI agent fixing phase")
+        # Always log this important phase start for AI consumption
+        self.logger.info(
+            "AI agent fixing phase started",
+            ai_agent_fixing=True,
+            event_type="ai_fix_init",
+        )
         self._log_debug_phase_start()
 
     def _prepare_ai_fixing_environment(self, options: OptionsProtocol) -> None:
@@ -972,7 +1031,7 @@ class WorkflowPipeline:
 
     async def _setup_ai_fixing_workflow(
         self,
-    ) -> tuple[AgentCoordinator, list[t.Any]]:
+    ) -> tuple[EnhancedAgentCoordinator, list[t.Any]]:
         agent_coordinator = self._setup_agent_coordinator()
         issues = await self._collect_issues_from_failures()
         return agent_coordinator, issues
@@ -980,7 +1039,7 @@ class WorkflowPipeline:
     async def _execute_ai_fixes(
         self,
         options: OptionsProtocol,
-        agent_coordinator: AgentCoordinator,
+        agent_coordinator: EnhancedAgentCoordinator,
         issues: list[t.Any],
     ) -> bool:
         self.logger.info(f"AI agents will attempt to fix {len(issues)} issues")
@@ -994,16 +1053,25 @@ class WorkflowPipeline:
                 "started",
                 details={"ai_agent": True},
             )
+            # Log structured data to stderr for AI consumption
+            self.logger.info(
+                "AI agent fixing phase started",
+                ai_agent_fixing=True,
+                event_type="ai_fix_start",
+            )
 
-    def _setup_agent_coordinator(self) -> AgentCoordinator:
-        from crackerjack.agents.coordinator import AgentCoordinator
+    def _setup_agent_coordinator(self) -> EnhancedAgentCoordinator:
+        from crackerjack.agents.enhanced_coordinator import create_enhanced_coordinator
 
         agent_context = AgentContext(
             project_path=self.pkg_path,
             session_id=getattr(self.session, "session_id", None),
         )
 
-        agent_coordinator = AgentCoordinator(agent_context)
+        # Use enhanced coordinator with Claude Code agent integration
+        agent_coordinator = create_enhanced_coordinator(
+            context=agent_context, enable_external_agents=True
+        )
         agent_coordinator.initialize_agents()
         return agent_coordinator
 
@@ -1058,6 +1126,16 @@ class WorkflowPipeline:
         self.debugger.log_test_fixes(test_fixes)
         self.debugger.log_hook_fixes(hook_fixes)
 
+        # Log structured data to stderr for AI consumption
+        self.logger.info(
+            "AI fixes applied",
+            ai_agent_fixing=True,
+            event_type="ai_fix_counts",
+            total_fixes=total_fixes,
+            test_fixes=test_fixes,
+            hook_fixes=hook_fixes,
+        )
+
     def _log_debug_phase_completion(self, success: bool, fix_result: t.Any) -> None:
         if self._should_debug():
             self.debugger.log_workflow_phase(
@@ -1069,6 +1147,16 @@ class WorkflowPipeline:
                     "remaining_issues": len(fix_result.remaining_issues),
                 },
             )
+            # Log structured data to stderr for AI consumption
+            self.logger.info(
+                f"AI agent fixing phase {'completed' if success else 'failed'}",
+                ai_agent_fixing=True,
+                event_type="ai_fix_completion",
+                success=success,
+                confidence=fix_result.confidence,
+                fixes_applied=len(fix_result.fixes_applied),
+                remaining_issues=len(fix_result.remaining_issues),
+            )
 
     def _handle_fixing_phase_error(self, error: Exception) -> bool:
         self.logger.exception(f"AI agent fixing phase failed: {error}")
@@ -1081,6 +1169,14 @@ class WorkflowPipeline:
                 "failed",
                 details={"error": str(error)},
             )
+            # Log structured data to stderr for AI consumption
+            self.logger.error(
+                "AI agent fixing phase failed",
+                ai_agent_fixing=True,
+                event_type="ai_fix_error",
+                error=str(error),
+                error_type=type(error).__name__,
+            )
 
         return False
 
@@ -1116,15 +1212,16 @@ class WorkflowPipeline:
         return test_success
 
     def _should_verify_hook_fixes(self, fixes_applied: list[str]) -> bool:
-        hook_fixes = [
-            f
-            for f in fixes_applied
-            if "hook" not in f.lower()
-            or "complexity" in f.lower()
-            or "type" in f.lower()
-        ]
+        hook_fixes = [fix for fix in fixes_applied if self._is_hook_related_fix(fix)]
         return bool(hook_fixes)
 
+    def _is_hook_related_fix(self, fix: str) -> bool:
+        """Check if a fix is related to hooks and should trigger hook verification."""
+        fix_lower = fix.lower()
+        return (
+            "hook" not in fix_lower or "complexity" in fix_lower or "type" in fix_lower
+        )
+
     async def _verify_hook_fixes(self, options: OptionsProtocol) -> bool:
         self.logger.info("Re-running comprehensive hooks to verify hook fixes")
         hook_success = self.phases.run_comprehensive_hooks_only(options)
@@ -1299,35 +1396,30 @@ class WorkflowPipeline:
         return issues
 
     def _parse_comprehensive_hook_errors(self, error_msg: str) -> list[Issue]:
-        issues: list[Issue] = []
         error_lower = error_msg.lower()
+        error_checkers = self._get_comprehensive_error_checkers()
 
-        complexity_issue = self._check_complexity_error(error_lower)
-        if complexity_issue:
-            issues.append(complexity_issue)
-
-        type_error_issue = self._check_type_error(error_lower)
-        if type_error_issue:
-            issues.append(type_error_issue)
-
-        security_issue = self._check_security_error(error_lower)
-        if security_issue:
-            issues.append(security_issue)
-
-        performance_issue = self._check_performance_error(error_lower)
-        if performance_issue:
-            issues.append(performance_issue)
-
-        dead_code_issue = self._check_dead_code_error(error_lower)
-        if dead_code_issue:
-            issues.append(dead_code_issue)
-
-        regex_issue = self._check_regex_validation_error(error_lower)
-        if regex_issue:
-            issues.append(regex_issue)
+        issues = []
+        for check_func in error_checkers:
+            issue = check_func(error_lower)
+            if issue:
+                issues.append(issue)
 
         return issues
 
+    def _get_comprehensive_error_checkers(
+        self,
+    ) -> list[t.Callable[[str], Issue | None]]:
+        """Get list of error checking functions for comprehensive hooks."""
+        return [
+            self._check_complexity_error,
+            self._check_type_error,
+            self._check_security_error,
+            self._check_performance_error,
+            self._check_dead_code_error,
+            self._check_regex_validation_error,
+        ]
+
     def _check_complexity_error(self, error_lower: str) -> Issue | None:
         if "complexipy" in error_lower or "c901" in error_lower:
             return Issue(
@@ -1426,24 +1518,66 @@ class WorkflowPipeline:
     def _classify_issue(self, issue_str: str) -> tuple[IssueType, Priority]:
         issue_lower = issue_str.lower()
 
-        if self._is_type_error(issue_lower):
-            return IssueType.TYPE_ERROR, Priority.HIGH
-        if self._is_security_issue(issue_lower):
-            return IssueType.SECURITY, Priority.HIGH
-        if self._is_complexity_issue(issue_lower):
-            return IssueType.COMPLEXITY, Priority.HIGH
-        if self._is_regex_validation_issue(issue_lower):
-            return IssueType.REGEX_VALIDATION, Priority.HIGH
-
-        if self._is_dead_code_issue(issue_lower):
-            return IssueType.DEAD_CODE, Priority.MEDIUM
-        if self._is_performance_issue(issue_lower):
-            return IssueType.PERFORMANCE, Priority.MEDIUM
-        if self._is_import_error(issue_lower):
-            return IssueType.IMPORT_ERROR, Priority.MEDIUM
+        # Check high priority issues first
+        high_priority_result = self._check_high_priority_issues(issue_lower)
+        if high_priority_result:
+            return high_priority_result
 
+        # Check medium priority issues
+        medium_priority_result = self._check_medium_priority_issues(issue_lower)
+        if medium_priority_result:
+            return medium_priority_result
+
+        # Default to formatting issue
         return IssueType.FORMATTING, Priority.MEDIUM
 
+    def _check_high_priority_issues(
+        self, issue_lower: str
+    ) -> tuple[IssueType, Priority] | None:
+        """Check for high priority issue types.
+
+        Args:
+            issue_lower: Lowercase issue string
+
+        Returns:
+            Tuple of issue type and priority if found, None otherwise
+        """
+        high_priority_checks = [
+            (self._is_type_error, IssueType.TYPE_ERROR),
+            (self._is_security_issue, IssueType.SECURITY),
+            (self._is_complexity_issue, IssueType.COMPLEXITY),
+            (self._is_regex_validation_issue, IssueType.REGEX_VALIDATION),
+        ]
+
+        for check_func, issue_type in high_priority_checks:
+            if check_func(issue_lower):
+                return issue_type, Priority.HIGH
+
+        return None
+
+    def _check_medium_priority_issues(
+        self, issue_lower: str
+    ) -> tuple[IssueType, Priority] | None:
+        """Check for medium priority issue types.
+
+        Args:
+            issue_lower: Lowercase issue string
+
+        Returns:
+            Tuple of issue type and priority if found, None otherwise
+        """
+        medium_priority_checks = [
+            (self._is_dead_code_issue, IssueType.DEAD_CODE),
+            (self._is_performance_issue, IssueType.PERFORMANCE),
+            (self._is_import_error, IssueType.IMPORT_ERROR),
+        ]
+
+        for check_func, issue_type in medium_priority_checks:
+            if check_func(issue_lower):
+                return issue_type, Priority.MEDIUM
+
+        return None
+
     def _is_type_error(self, issue_lower: str) -> bool:
         return any(
             keyword in issue_lower for keyword in ("type", "annotation", "pyright")
@@ -1512,78 +1646,76 @@ class WorkflowPipeline:
     async def _handle_security_gate_failure(
         self, options: OptionsProtocol, allow_ai_fixing: bool = False
     ) -> bool:
+        self._display_security_gate_failure_message()
+
+        if allow_ai_fixing:
+            return await self._attempt_ai_assisted_security_fix(options)
+        return self._handle_manual_security_fix()
+
+    def _display_security_gate_failure_message(self) -> None:
+        """Display initial security gate failure message."""
         self.console.print(
             "[red]🔒 SECURITY GATE: Critical security checks failed[/red]"
         )
 
-        if allow_ai_fixing:
-            self.console.print(
-                "[red]Security-critical hooks (bandit, pyright, gitleaks) must pass before publishing[/red]"
-            )
-            self.console.print(
-                "[yellow]🤖 Attempting AI-assisted security issue resolution...[/yellow]"
-            )
+    async def _attempt_ai_assisted_security_fix(self, options: OptionsProtocol) -> bool:
+        """Attempt to fix security issues using AI assistance.
 
-            ai_fix_success = await self._run_ai_agent_fixing_phase(options)
-            if ai_fix_success:
-                try:
-                    security_still_blocks = self._check_security_critical_failures()
-                    if not security_still_blocks:
-                        self.console.print(
-                            "[green]✅ AI agents resolved security issues - publishing allowed[/green]"
-                        )
-                        return True
-                    else:
-                        self.console.print(
-                            "[red]🔒 Security issues persist after AI fixing - publishing still BLOCKED[/red]"
-                        )
-                        return False
-                except Exception as e:
-                    self.logger.warning(
-                        f"Security re-check failed: {e} - blocking publishing"
-                    )
-                    return False
-            return False
-        else:
-            self.console.print(
-                "[red]Security-critical hooks (bandit, pyright, gitleaks) must pass before publishing[/red]"
-            )
-            return False
+        Args:
+            options: Configuration options
 
-    def _determine_ai_fixing_needed(
-        self,
-        testing_passed: bool,
-        comprehensive_passed: bool,
-        publishing_requested: bool,
-    ) -> bool:
-        if publishing_requested:
-            return not testing_passed or not comprehensive_passed
+        Returns:
+            True if security issues were resolved, False otherwise
+        """
+        self._display_ai_fixing_messages()
 
-        return not testing_passed or not comprehensive_passed
+        ai_fix_success = await self._run_ai_agent_fixing_phase(options)
+        if ai_fix_success:
+            return self._verify_security_fix_success()
 
-    def _determine_workflow_success(
-        self,
-        testing_passed: bool,
-        comprehensive_passed: bool,
-        publishing_requested: bool,
-    ) -> bool:
-        if publishing_requested:
-            return testing_passed and comprehensive_passed
+        return False
+
+    def _display_ai_fixing_messages(self) -> None:
+        """Display messages about AI-assisted security fixing."""
+        self.console.print(
+            "[red]Security-critical hooks (bandit, pyright, gitleaks) must pass before publishing[/red]"
+        )
+        self.console.print(
+            "[yellow]🤖 Attempting AI-assisted security issue resolution...[/yellow]"
+        )
 
-        return testing_passed and comprehensive_passed
+    def _verify_security_fix_success(self) -> bool:
+        """Verify that AI fixes resolved the security issues.
 
-    def _show_verbose_failure_details(
-        self, testing_passed: bool, comprehensive_passed: bool
-    ) -> None:
+        Returns:
+            True if security issues were resolved, False otherwise
+        """
+        try:
+            security_still_blocks = self._check_security_critical_failures()
+            if not security_still_blocks:
+                self.console.print(
+                    "[green]✅ AI agents resolved security issues - publishing allowed[/green]"
+                )
+                return True
+            else:
+                self.console.print(
+                    "[red]🔒 Security issues persist after AI fixing - publishing still BLOCKED[/red]"
+                )
+                return False
+        except Exception as e:
+            self.logger.warning(f"Security re-check failed: {e} - blocking publishing")
+            return False
+
+    def _handle_manual_security_fix(self) -> bool:
+        """Handle security fix when AI assistance is not allowed.
+
+        Returns:
+            Always False since manual intervention is required
+        """
         self.console.print(
-            f"[yellow]⚠️ Quality phase results - testing_passed: {testing_passed}, comprehensive_passed: {comprehensive_passed}[/yellow]"
+            "[red]Security-critical hooks (bandit, pyright, gitleaks) must pass before publishing[/red]"
         )
-        if not testing_passed:
-            self.console.print("[yellow] → Tests reported failure[/yellow]")
-        if not comprehensive_passed:
-            self.console.print(
-                "[yellow] → Comprehensive hooks reported failure[/yellow]"
-            )
+        return False
 
     def _check_security_critical_failures(self) -> bool:
         try:
@@ -1680,141 +1812,60 @@ class WorkflowPipeline:
 
         return hook_name in security_critical_hooks and is_failed
 
-    def _show_security_audit_warning(self) -> None:
-        audit_report = getattr(self, "_last_security_audit", None)
-
-        if audit_report:
-            self.console.print(
-                "[yellow]⚠️ SECURITY AUDIT: Proceeding with partial quality success[/yellow]"
-            )
-
-            for warning in audit_report.security_warnings:
-                if "CRITICAL" in warning:
-                    self.console.print(f"[red]{warning}[/red]")
-                elif "HIGH" in warning:
-                    self.console.print(f"[yellow]{warning}[/yellow]")
-                else:
-                    self.console.print(f"[blue]{warning}[/blue]")
-
-            if audit_report.recommendations:
-                self.console.print("[bold]Security Recommendations: [/bold]")
-                for rec in audit_report.recommendations[:3]:
-                    self.console.print(f"[dim]{rec}[/dim]")
-        else:
-            self.console.print(
-                "[yellow]⚠️ SECURITY AUDIT: Proceeding with partial quality success[/yellow]"
-            )
-            self.console.print(
-                "[yellow]✅ Security-critical checks (bandit, pyright, gitleaks) have passed[/yellow]"
-            )
-            self.console.print(
-                "[yellow]⚠️ Some non-critical quality checks failed - consider reviewing before production deployment[/yellow]"
-            )
-
-    async def _run_initial_fast_hooks_async(
-        self, options: OptionsProtocol, iteration: int, monitor: t.Any
-    ) -> bool:
-        monitor.record_sequential_op()
-        fast_hooks_passed = self._run_fast_hooks_phase(options)
-        if not fast_hooks_passed:
-            if options.ai_agent and self._should_debug():
-                self.debugger.log_iteration_end(iteration, False)
-            return False
-        return True
-
-    async def _run_fast_hooks_phase_monitored(
-        self, options: OptionsProtocol, workflow_id: str
-    ) -> bool:
-        with phase_monitor(workflow_id, "fast_hooks") as monitor:
-            monitor.record_sequential_op()
-            return self._run_fast_hooks_phase(options)
-
-    async def _run_comprehensive_hooks_phase_monitored(
-        self, options: OptionsProtocol, workflow_id: str
-    ) -> bool:
-        with phase_monitor(workflow_id, "comprehensive_hooks") as monitor:
-            monitor.record_sequential_op()
-            return self._run_comprehensive_hooks_phase(options)
-
-    async def _run_testing_phase_async(
-        self, options: OptionsProtocol, workflow_id: str
-    ) -> bool:
-        with phase_monitor(workflow_id, "testing") as monitor:
-            monitor.record_sequential_op()
-            return self._run_testing_phase(options)
-
-    async def _execute_standard_hooks_workflow_monitored(
-        self, options: OptionsProtocol, workflow_id: str
-    ) -> bool:
-        with phase_monitor(workflow_id, "hooks") as monitor:
-            self._update_hooks_status_running()
-
-            fast_hooks_success = self._execute_monitored_fast_hooks_phase(
-                options, monitor
-            )
-            if not fast_hooks_success:
-                self._handle_hooks_completion(False)
-                return False
+    def _workflow_context(
+        self,
+        workflow_id: str,
+        options: OptionsProtocol,
+    ) -> dict[str, t.Any]:
+        """Build a consistent payload for workflow-level events."""
+        return {
+            "workflow_id": workflow_id,
+            "test_mode": getattr(options, "test", False),
+            "skip_hooks": getattr(options, "skip_hooks", False),
+            "publish": getattr(options, "publish", False),
+            "all": getattr(options, "all", False),
+            "commit": getattr(options, "commit", False),
+            "ai_agent": getattr(options, "ai_agent", False),
+        }
 
-            if not self._execute_monitored_cleaning_phase(options):
-                self._handle_hooks_completion(False)
-                return False
+    async def _publish_event(
+        self, event: WorkflowEvent, payload: dict[str, t.Any]
+    ) -> None:
+        """Publish workflow events when the bus is available."""
+        if not getattr(self, "_event_bus", None):
+            return
 
-            comprehensive_success = self._execute_monitored_comprehensive_phase(
-                options, monitor
+        try:
+            await self._event_bus.publish(event, payload)  # type: ignore[union-attr]
+        except Exception as exc:  # pragma: no cover - logging only
+            self.logger.debug(
+                "Failed to publish workflow event",
+                extra={"event": event.value, "error": str(exc)},
             )
 
-            hooks_success = fast_hooks_success and comprehensive_success
-            self._handle_hooks_completion(hooks_success)
-            return hooks_success
-
-    def _execute_monitored_fast_hooks_phase(
-        self, options: OptionsProtocol, monitor: t.Any
-    ) -> bool:
-        fast_hooks_success = self._run_fast_hooks_phase(options)
-        if fast_hooks_success:
-            monitor.record_sequential_op()
-        return fast_hooks_success
-
-    def _execute_monitored_cleaning_phase(self, options: OptionsProtocol) -> bool:
-        if not getattr(options, "clean", False):
-            return True
-
-        if not self._run_code_cleaning_phase(options):
-            return False
-
-        if not self._run_post_cleaning_fast_hooks(options):
-            return False
-
-        self._mark_code_cleaning_complete()
-        return True
-
-    def _execute_monitored_comprehensive_phase(
-        self, options: OptionsProtocol, monitor: t.Any
-    ) -> bool:
-        comprehensive_success = self._run_comprehensive_hooks_phase(options)
-        if comprehensive_success:
-            monitor.record_sequential_op()
-        return comprehensive_success
-
 
 class WorkflowOrchestrator:
     def __init__(
         self,
-        console: Console | None = None,
         pkg_path: Path | None = None,
         dry_run: bool = False,
         web_job_id: str | None = None,
         verbose: bool = False,
         debug: bool = False,
+        changed_only: bool = False,
     ) -> None:
-        self.console = console or Console(force_terminal=True)
+        # Initialize console and pkg_path first
+        from acb.console import Console
+
+        self.console = depends.get_sync(Console)
         self.pkg_path = pkg_path or Path.cwd()
         self.dry_run = dry_run
         self.web_job_id = web_job_id
         self.verbose = verbose
         self.debug = debug
+        self.changed_only = changed_only
 
+        # Import protocols for retrieving dependencies via ACB
         from crackerjack.models.protocols import (
             ConfigMergeServiceProtocol,
             FileSystemInterface,
@@ -1824,41 +1875,207 @@ class WorkflowOrchestrator:
             TestManagerProtocol,
         )
 
+        # Setup services with ACB DI
+        self._setup_acb_services()
+
         self._initialize_logging()
 
-        self.logger = get_logger("crackerjack.orchestrator")
+        self.logger = depends.get_sync(LoggerProtocol)
 
-        from .enhanced_container import create_enhanced_container
+        # Create coordinators - dependencies retrieved via ACB's depends.get_sync()
+        self.session = SessionCoordinator(self.console, self.pkg_path, self.web_job_id)
 
-        self.container = create_enhanced_container(
-            console=self.console,
-            pkg_path=self.pkg_path,
-            dry_run=self.dry_run,
-            verbose=self.verbose,
-        )
+        # Register SessionCoordinator in DI for WorkflowPipeline injection
+        depends.set(SessionCoordinator, self.session)
 
-        self.session = SessionCoordinator(self.console, self.pkg_path, self.web_job_id)
         self.phases = PhaseCoordinator(
             console=self.console,
             pkg_path=self.pkg_path,
             session=self.session,
-            filesystem=self.container.get(FileSystemInterface),
-            git_service=self.container.get(GitInterface),
-            hook_manager=self.container.get(HookManager),
-            test_manager=self.container.get(TestManagerProtocol),
-            publish_manager=self.container.get(PublishManager),
-            config_merge_service=self.container.get(ConfigMergeServiceProtocol),
+            filesystem=depends.get_sync(FileSystemInterface),
+            git_service=depends.get_sync(GitInterface),
+            hook_manager=depends.get_sync(HookManager),
+            test_manager=depends.get_sync(TestManagerProtocol),
+            publish_manager=depends.get_sync(PublishManager),
+            config_merge_service=depends.get_sync(ConfigMergeServiceProtocol),
+        )
+
+        # Register PhaseCoordinator in DI for WorkflowPipeline injection
+        depends.set(PhaseCoordinator, self.phases)
+
+        # WorkflowPipeline uses @depends.inject, so all parameters are auto-injected
+        self.pipeline = WorkflowPipeline()
+
+    def _setup_acb_services(self) -> None:
+        """Setup all services using ACB dependency injection."""
+        self._register_filesystem_and_git_services()
+        self._register_manager_services()
+        self._register_core_services()
+        self._register_quality_services()
+        self._register_monitoring_services()
+        self._setup_event_system()
+
+    def _register_filesystem_and_git_services(self) -> None:
+        """Register filesystem and git services."""
+        from acb.depends import depends
+
+        from crackerjack.models.protocols import (
+            FileSystemInterface,
+            GitInterface,
+            GitServiceProtocol,
         )
+        from crackerjack.services.enhanced_filesystem import EnhancedFileSystemService
+        from crackerjack.services.git import GitService
 
-        self.pipeline = WorkflowPipeline(
+        filesystem = EnhancedFileSystemService()
+        depends.set(FileSystemInterface, filesystem)
+
+        git_service = GitService(self.pkg_path)
+        depends.set(GitInterface, git_service)
+        depends.set(GitServiceProtocol, git_service)
+
+    def _register_manager_services(self) -> None:
+        """Register hook, test, and publish managers."""
+        from acb.depends import depends
+
+        from crackerjack.managers.hook_manager import HookManagerImpl
+        from crackerjack.managers.publish_manager import PublishManagerImpl
+        from crackerjack.managers.test_manager import TestManager
+        from crackerjack.models.protocols import (
+            HookManager,
+            PublishManager,
+            TestManagerProtocol,
+        )
+
+        hook_manager = HookManagerImpl(
+            self.pkg_path,
+            verbose=self.verbose,
+            debug=self.debug,
+            use_incremental=self.changed_only,
+        )
+        depends.set(HookManager, hook_manager)
+
+        test_manager = TestManager()
+        depends.set(TestManagerProtocol, test_manager)
+
+        publish_manager = PublishManagerImpl()
+        depends.set(PublishManager, publish_manager)
+
+    def _register_core_services(self) -> None:
+        """Register core configuration and security services."""
+        from acb.depends import depends
+
+        from crackerjack.executors.hook_lock_manager import HookLockManager
+        from crackerjack.models.protocols import (
+            ConfigIntegrityServiceProtocol,
+            ConfigMergeServiceProtocol,
+            EnhancedFileSystemServiceProtocol,
+            HookLockManagerProtocol,
+            SecurityServiceProtocol,
+            SmartSchedulingServiceProtocol,
+            UnifiedConfigurationServiceProtocol,
+        )
+        from crackerjack.services.cache import CrackerjackCache
+        from crackerjack.services.config_integrity import ConfigIntegrityService
+        from crackerjack.services.config_merge import ConfigMergeService
+        from crackerjack.services.enhanced_filesystem import EnhancedFileSystemService
+        from crackerjack.services.security import SecurityService
+        from crackerjack.services.smart_scheduling import SmartSchedulingService
+        from crackerjack.services.unified_config import UnifiedConfigurationService
+
+        depends.set(
+            UnifiedConfigurationServiceProtocol,
+            UnifiedConfigurationService(pkg_path=self.pkg_path),
+        )
+        depends.set(
+            ConfigIntegrityServiceProtocol,
+            ConfigIntegrityService(project_path=self.pkg_path),
+        )
+        depends.set(ConfigMergeServiceProtocol, ConfigMergeService())
+        depends.set(
+            SmartSchedulingServiceProtocol,
+            SmartSchedulingService(project_path=self.pkg_path),
+        )
+        depends.set(EnhancedFileSystemServiceProtocol, EnhancedFileSystemService())
+        depends.set(SecurityServiceProtocol, SecurityService())
+        depends.set(HookLockManagerProtocol, HookLockManager())
+        depends.set(CrackerjackCache, CrackerjackCache())
+
+    def _register_quality_services(self) -> None:
+        """Register coverage, version analysis, and code quality services."""
+        from acb.depends import depends
+
+        from crackerjack.models.protocols import (
+            ChangelogGeneratorProtocol,
+            CoverageBadgeServiceProtocol,
+            CoverageRatchetProtocol,
+            GitInterface,
+            RegexPatternsProtocol,
+            VersionAnalyzerProtocol,
+        )
+        from crackerjack.services.changelog_automation import ChangelogGenerator
+        from crackerjack.services.coverage_badge_service import CoverageBadgeService
+        from crackerjack.services.coverage_ratchet import CoverageRatchetService
+        from crackerjack.services.regex_patterns import RegexPatternsService
+        from crackerjack.services.version_analyzer import VersionAnalyzer
+
+        coverage_ratchet = CoverageRatchetService(self.pkg_path)
+        depends.set(CoverageRatchetProtocol, coverage_ratchet)
+
+        coverage_badge = CoverageBadgeService(project_root=self.pkg_path)
+        depends.set(CoverageBadgeServiceProtocol, coverage_badge)
+
+        git_service = depends.get_sync(GitInterface)
+        version_analyzer = VersionAnalyzer(git_service=git_service)
+        depends.set(VersionAnalyzerProtocol, version_analyzer)
+
+        changelog_generator = ChangelogGenerator()
+        depends.set(ChangelogGeneratorProtocol, changelog_generator)
+
+        regex_patterns = RegexPatternsService()
+        depends.set(RegexPatternsProtocol, regex_patterns)
+
+    def _register_monitoring_services(self) -> None:
+        """Register performance monitoring and benchmarking services."""
+        from acb.depends import depends
+        from acb.logger import Logger
+
+        from crackerjack.models.protocols import PerformanceBenchmarkProtocol
+        from crackerjack.services.monitoring.performance_benchmarks import (
+            PerformanceBenchmarkService,
+        )
+
+        performance_benchmarks = PerformanceBenchmarkService(
             console=self.console,
+            logger=depends.get_sync(Logger),
             pkg_path=self.pkg_path,
-            session=self.session,
-            phases=self.phases,
         )
+        depends.set(PerformanceBenchmarkProtocol, performance_benchmarks)
+
+    def _setup_event_system(self) -> None:
+        """Setup event bus and telemetry."""
+        from acb.depends import depends
+
+        from crackerjack.events import (
+            WorkflowEventBus,
+            WorkflowEventTelemetry,
+            register_default_subscribers,
+        )
+
+        default_state_dir = Path.home() / ".crackerjack" / "state"
+        default_state_dir.mkdir(parents=True, exist_ok=True)
+
+        event_bus = WorkflowEventBus()
+        telemetry_state_file = default_state_dir / "workflow_events.json"
+        telemetry = WorkflowEventTelemetry(state_file=telemetry_state_file)
+        register_default_subscribers(event_bus, telemetry)
+
+        depends.set(WorkflowEventBus, event_bus)
+        depends.set(WorkflowEventTelemetry, telemetry)
 
     def _initialize_logging(self) -> None:
         from crackerjack.services.log_manager import get_log_manager
+        from crackerjack.services.logging import setup_structured_logging
 
         log_manager = get_log_manager()
         session_id = getattr(self, "web_job_id", None) or str(int(time.time()))[:8]
@@ -1869,7 +2086,7 @@ class WorkflowOrchestrator:
             level=log_level, json_output=False, log_file=debug_log_file
         )
 
-        temp_logger = get_logger("crackerjack.orchestrator.init")
+        temp_logger = depends.get_sync(LoggerProtocol)
         temp_logger.debug(
             "Structured logging initialized",
             log_file=str(debug_log_file),
@@ -1891,33 +2108,102 @@ class WorkflowOrchestrator:
         self.session.fail_task(task_id, error)
 
     def run_cleaning_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_cleaning_phase(options)
+        result: bool = self.phases.run_cleaning_phase(options)  # type: ignore[arg-type,assignment]
+        return result
 
     def run_fast_hooks_only(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_fast_hooks_only(options)
+        result: bool = self.phases.run_fast_hooks_only(options)  # type: ignore[arg-type,assignment]
+        return result
 
     def run_comprehensive_hooks_only(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_comprehensive_hooks_only(options)
+        result: bool = self.phases.run_comprehensive_hooks_only(options)  # type: ignore[arg-type,assignment]
+        return result
 
     def run_hooks_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_hooks_phase(options)
+        result: bool = self.phases.run_hooks_phase(options)  # type: ignore[arg-type,assignment]
+        return result
 
     def run_testing_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_testing_phase(options)
+        result: bool = self.phases.run_testing_phase(options)  # type: ignore[arg-type,assignment]
+        return result
 
     def run_publishing_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_publishing_phase(options)
+        result: bool = self.phases.run_publishing_phase(options)  # type: ignore[arg-type,assignment]
+        return result
 
     def run_commit_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_commit_phase(options)
+        result: bool = self.phases.run_commit_phase(options)  # type: ignore[arg-type,assignment]
+        return result
 
     def run_configuration_phase(self, options: OptionsProtocol) -> bool:
-        return self.phases.run_configuration_phase(options)
+        result: bool = self.phases.run_configuration_phase(options)  # type: ignore[arg-type,assignment]
+        return result
 
     async def run_complete_workflow(self, options: OptionsProtocol) -> bool:
         result: bool = await self.pipeline.run_complete_workflow(options)
+        # Ensure we properly clean up any pending tasks before finishing
+        await self._cleanup_pending_tasks()
         return result
 
+    async def _cleanup_pending_tasks(self) -> None:
+        """Clean up any remaining asyncio tasks before event loop closes."""
+        # First call the pipeline cleanup methods if they exist
+        await self._cleanup_pipeline_executors()
+
+        # Then handle general asyncio task cleanup
+        await self._cleanup_remaining_tasks()
+
+    async def _cleanup_pipeline_executors(self) -> None:
+        """Clean up specific pipeline executors."""
+        with suppress(Exception):
+            # Try to call specific async cleanup methods on executors/pipeline if they exist
+            if hasattr(self, "pipeline") and hasattr(self.pipeline, "phases"):
+                await self._cleanup_executor_if_exists(
+                    self.pipeline.phases, "_parallel_executor"
+                )
+                await self._cleanup_executor_if_exists(
+                    self.pipeline.phases, "_async_executor"
+                )
+
+    async def _cleanup_executor_if_exists(
+        self, phases_obj: t.Any, executor_attr: str
+    ) -> None:
+        """Clean up an executor if it exists and has the required cleanup method."""
+        if hasattr(phases_obj, executor_attr):
+            executor = getattr(phases_obj, executor_attr)
+            if hasattr(executor, "async_cleanup"):
+                await executor.async_cleanup()
+
+    async def _cleanup_remaining_tasks(self) -> None:
+        """Clean up any remaining asyncio tasks."""
+        with suppress(RuntimeError):
+            loop = asyncio.get_running_loop()
+            # Get all pending tasks
+            pending_tasks = [
+                task for task in asyncio.all_tasks(loop) if not task.done()
+            ]
+            await self._cancel_pending_tasks(pending_tasks)
+
+    async def _cancel_pending_tasks(self, pending_tasks: list) -> None:
+        """Cancel pending tasks with proper error handling."""
+        for task in pending_tasks:
+            if not task.done():
+                try:
+                    task.cancel()
+                    # Wait a short time for cancellation to complete
+                    await asyncio.wait_for(task, timeout=0.1)
+                except (TimeoutError, asyncio.CancelledError):
+                    # Task was cancelled or couldn't finish in time, continue
+                    pass
+                except RuntimeError as e:
+                    # Catch the specific error when event loop is closed during task cancellation
+                    if "Event loop is closed" in str(e):
+                        # Event loop was closed while trying to cancel tasks, just return
+                        return
+                    else:
+                        # Re-raise other RuntimeErrors
+                        raise
+
     def run_complete_workflow_sync(self, options: OptionsProtocol) -> bool:
         """Sync wrapper for run_complete_workflow."""
         return asyncio.run(self.run_complete_workflow(options))
@@ -1933,7 +2219,7 @@ class WorkflowOrchestrator:
 
     def _get_version(self) -> str:
         try:
-            return version()
+            return version("crackerjack")
         except Exception:
             return "unknown"
 
@@ -1942,8 +2228,16 @@ class WorkflowOrchestrator:
 
         try:
             result = await self.run_complete_workflow(options)
-            self.session.end_session(success=result)
-            return result
+            return self._finalize_session_with_result(result)
         except Exception:
-            self.session.end_session(success=False)
-            return False
+            return self._finalize_session_on_exception()
+
+    def _finalize_session_with_result(self, result: bool) -> bool:
+        """Finalize session with the workflow result."""
+        self.session.end_session(success=result)
+        return result
+
+    def _finalize_session_on_exception(self) -> bool:
+        """Finalize session when an exception occurs."""
+        self.session.end_session(success=False)
+        return False