crackerjack 0.31.10__py3-none-any.whl → 0.31.12__py3-none-any.whl

crackerjack/core/workflow_orchestrator.py

@@ -58,7 +58,7 @@ class WorkflowPipeline:
     async def run_complete_workflow(self, options: OptionsProtocol) -> bool:
         with LoggingContext(
             "workflow_execution",
-            testing=getattr(options, "testing", False),
+            testing=getattr(options, "test", False),
             skip_hooks=getattr(options, "skip_hooks", False),
         ):
             start_time = time.time()
@@ -78,7 +78,6 @@ class WorkflowPipeline:
                 self.session.cleanup_resources()
 
     def _initialize_workflow_session(self, options: OptionsProtocol) -> None:
-        """Initialize session tracking and debug logging for workflow execution."""
         self.session.initialize_session_tracking(options)
         self.session.track_task("workflow", "Complete crackerjack workflow")
 
@@ -87,7 +86,6 @@ class WorkflowPipeline:
         self._log_workflow_startup_info(options)
 
     def _log_workflow_startup_debug(self, options: OptionsProtocol) -> None:
-        """Log debug information for workflow startup."""
         if not self._should_debug():
             return
 
@@ -95,22 +93,20 @@ class WorkflowPipeline:
             "workflow_execution",
             "started",
             details={
-                "testing": getattr(options, "testing", False),
+                "testing": getattr(options, "test", False),
                 "skip_hooks": getattr(options, "skip_hooks", False),
                 "ai_agent": getattr(options, "ai_agent", False),
             },
         )
 
     def _configure_session_cleanup(self, options: OptionsProtocol) -> None:
-        """Configure session cleanup settings if specified."""
         if hasattr(options, "cleanup"):
             self.session.set_cleanup_config(options.cleanup)
 
     def _log_workflow_startup_info(self, options: OptionsProtocol) -> None:
-        """Log informational message about workflow startup."""
         self.logger.info(
             "Starting complete workflow execution",
-            testing=getattr(options, "testing", False),
+            testing=getattr(options, "test", False),
             skip_hooks=getattr(options, "skip_hooks", False),
             package_path=str(self.pkg_path),
         )
@@ -118,7 +114,6 @@ class WorkflowPipeline:
     async def _execute_workflow_with_timing(
         self, options: OptionsProtocol, start_time: float
     ) -> bool:
-        """Execute workflow phases and handle success/completion logging."""
         success = await self._execute_workflow_phases(options)
         self.session.finalize_session(start_time, success)
 
@@ -129,7 +124,6 @@ class WorkflowPipeline:
         return success
 
     def _log_workflow_completion(self, success: bool, duration: float) -> None:
-        """Log workflow completion information."""
         self.logger.info(
             "Workflow execution completed",
             success=success,
@@ -137,7 +131,6 @@ class WorkflowPipeline:
         )
 
     def _log_workflow_completion_debug(self, success: bool, duration: float) -> None:
-        """Log debug information for workflow completion."""
         if not self._should_debug():
             return
 
@@ -152,14 +145,12 @@ class WorkflowPipeline:
             self.debugger.print_debug_summary()
 
     def _handle_user_interruption(self) -> bool:
-        """Handle KeyboardInterrupt gracefully."""
         self.console.print("Interrupted by user")
         self.session.fail_task("workflow", "Interrupted by user")
         self.logger.warning("Workflow interrupted by user")
         return False
 
     def _handle_workflow_exception(self, error: Exception) -> bool:
-        """Handle unexpected workflow exceptions."""
         self.console.print(f"Error: {error}")
         self.session.fail_task("workflow", f"Unexpected error: {error}")
         self.logger.exception(
@@ -173,11 +164,8 @@ class WorkflowPipeline:
         success = True
         self.phases.run_configuration_phase(options)
 
-        if not self.phases.run_cleaning_phase(options):
-            success = False
-            self.session.fail_task("workflow", "Cleaning phase failed")
-            return False
-
+        # Code cleaning is now integrated into the quality phase
+        # to run after fast hooks but before comprehensive hooks
         if not await self._execute_quality_phase(options):
             success = False
             return False
@@ -195,7 +183,7 @@ class WorkflowPipeline:
             return self._run_fast_hooks_phase(options)
         if hasattr(options, "comp") and options.comp:
             return self._run_comprehensive_hooks_phase(options)
-        if options.test:
+        if getattr(options, "test", False):
             return await self._execute_test_workflow(options)
         return self._execute_standard_hooks_workflow(options)
 
@@ -205,6 +193,15 @@ class WorkflowPipeline:
         if not self._run_initial_fast_hooks(options, iteration):
             return False
 
+        # Run code cleaning after fast hooks but before comprehensive hooks
+        if getattr(options, "clean", False):
+            if not self._run_code_cleaning_phase(options):
+                return False
+            # Run fast hooks again after cleaning for sanity check
+            if not self._run_post_cleaning_fast_hooks(options):
+                return False
+            self._mark_code_cleaning_complete()
+
         testing_passed, comprehensive_passed = self._run_main_quality_phases(options)
 
         if options.ai_agent:
@@ -217,23 +214,20 @@ class WorkflowPipeline:
         )
 
     def _start_iteration_tracking(self, options: OptionsProtocol) -> int:
-        """Start iteration tracking for AI agent mode."""
         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:
-        """Run initial fast hooks phase and handle failure."""
         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  # Fast hooks must pass before proceeding
+            return False
         return True
 
     def _run_main_quality_phases(self, options: OptionsProtocol) -> tuple[bool, bool]:
-        """Run tests and comprehensive hooks to collect ALL issues."""
         testing_passed = self._run_testing_phase(options)
         comprehensive_passed = self._run_comprehensive_hooks_phase(options)
         return testing_passed, comprehensive_passed
@@ -245,7 +239,6 @@ class WorkflowPipeline:
         testing_passed: bool,
         comprehensive_passed: bool,
     ) -> bool:
-        """Handle AI agent workflow with failure collection and fixing."""
         if not testing_passed or not comprehensive_passed:
             success = await self._run_ai_agent_fixing_phase(options)
             if self._should_debug():
@@ -254,7 +247,7 @@ class WorkflowPipeline:
 
         if self._should_debug():
             self.debugger.log_iteration_end(iteration, True)
-        return True  # All phases passed, no fixes needed
+        return True
 
     def _handle_standard_workflow(
         self,
@@ -263,21 +256,19 @@ class WorkflowPipeline:
         testing_passed: bool,
         comprehensive_passed: bool,
     ) -> bool:
-        """Handle standard workflow where all phases must pass."""
         success = testing_passed and comprehensive_passed
 
-        # Debug information for workflow continuation issues
         if not success and getattr(options, "verbose", False):
             self.console.print(
-                f"[yellow]⚠️  Workflow stopped - testing_passed: {testing_passed}, comprehensive_passed: {comprehensive_passed}[/yellow]"
+                f"[yellow]⚠️ Workflow stopped-testing_passed: {testing_passed}, comprehensive_passed: {comprehensive_passed}[/ yellow]"
             )
             if not testing_passed:
                 self.console.print(
-                    "[yellow]   → Tests reported failure despite appearing successful[/yellow]"
+                    "[yellow] → Tests reported failure despite appearing successful[/ yellow]"
                 )
             if not comprehensive_passed:
                 self.console.print(
-                    "[yellow]   → Comprehensive hooks reported failure despite appearing successful[/yellow]"
+                    "[yellow] → Comprehensive hooks reported failure despite appearing successful[/ yellow]"
                 )
 
         if options.ai_agent and self._should_debug():
@@ -303,8 +294,7 @@ class WorkflowPipeline:
             self.session.fail_task("workflow", "Testing failed")
             self._handle_test_failures()
             self._update_mcp_status("tests", "failed")
-            # In AI agent mode, continue to collect more failures
-            # In non-AI mode, this will be handled by caller
+
         else:
             self._update_mcp_status("tests", "completed")
 
@@ -317,8 +307,7 @@ class WorkflowPipeline:
         if not success:
             self.session.fail_task("comprehensive_hooks", "Comprehensive hooks failed")
             self._update_mcp_status("comprehensive", "failed")
-            # In AI agent mode, continue to collect more failures
-            # In non-AI mode, this will be handled by caller
+
         else:
             self._update_mcp_status("comprehensive", "completed")
 
@@ -328,7 +317,41 @@ class WorkflowPipeline:
         if hasattr(self, "_mcp_state_manager") and self._mcp_state_manager:
             self._mcp_state_manager.update_stage_status(stage, status)
 
-        self.session.update_stage(stage, status)
+    def _run_code_cleaning_phase(self, options: OptionsProtocol) -> bool:
+        """Run code cleaning phase after fast hooks but before comprehensive hooks."""
+        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:
+        """Run fast hooks again after code cleaning for sanity check."""
+        self.console.print(
+            "\n[bold cyan]🔍 Running Post-Cleaning Fast Hooks Sanity Check...[/bold cyan]"
+        )
+
+        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:
+        """Check if code cleaning has already run in this workflow."""
+        return getattr(self, "_code_cleaning_complete", False)
+
+    def _mark_code_cleaning_complete(self) -> None:
+        """Mark code cleaning as complete for this workflow."""
+        self._code_cleaning_complete = True
 
     def _handle_test_failures(self) -> None:
         if not (hasattr(self, "_mcp_state_manager") and self._mcp_state_manager):
@@ -340,7 +363,6 @@ class WorkflowPipeline:
 
         failures = test_manager.get_test_failures()
 
-        # Log test failure count for debugging
         if self._should_debug():
             self.debugger.log_test_failures(len(failures))
 
@@ -351,7 +373,7 @@ class WorkflowPipeline:
                 id=f"test_failure_{i}",
                 type="test_failure",
                 message=failure.strip(),
-                file_path="tests/",
+                file_path="tests /",
                 priority=Priority.HIGH,
                 stage="tests",
                 auto_fixable=False,
@@ -359,22 +381,39 @@ class WorkflowPipeline:
             self._mcp_state_manager.add_issue(issue)
 
     def _execute_standard_hooks_workflow(self, options: OptionsProtocol) -> bool:
-        """Execute standard hooks workflow with proper state management."""
         self._update_hooks_status_running()
 
-        hooks_success = self.phases.run_hooks_phase(options)
+        # Run fast hooks first
+        fast_hooks_success = self._run_fast_hooks_phase(options)
+        if not fast_hooks_success:
+            self._handle_hooks_completion(False)
+            return False
+
+        # Run code cleaning after fast hooks but before comprehensive hooks
+        if getattr(options, "clean", False):
+            if not self._run_code_cleaning_phase(options):
+                self._handle_hooks_completion(False)
+                return False
+            # Run fast hooks again after cleaning for sanity check
+            if not self._run_post_cleaning_fast_hooks(options):
+                self._handle_hooks_completion(False)
+                return False
+            self._mark_code_cleaning_complete()
+
+        # Run comprehensive hooks
+        comprehensive_success = self._run_comprehensive_hooks_phase(options)
+
+        hooks_success = fast_hooks_success and comprehensive_success
         self._handle_hooks_completion(hooks_success)
 
         return hooks_success
 
     def _update_hooks_status_running(self) -> None:
-        """Update MCP state to running for hook phases."""
         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 _handle_hooks_completion(self, hooks_success: bool) -> None:
-        """Handle hooks completion with appropriate status updates."""
         if not hooks_success:
             self.session.fail_task("workflow", "Hooks failed")
             self._update_hooks_status_failed()
@@ -382,28 +421,35 @@ class WorkflowPipeline:
             self._update_hooks_status_completed()
 
     def _has_mcp_state_manager(self) -> bool:
-        """Check if MCP state manager is available."""
         return hasattr(self, "_mcp_state_manager") and self._mcp_state_manager
 
     def _update_hooks_status_failed(self) -> None:
-        """Update MCP state to failed for hook phases."""
         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 _update_hooks_status_completed(self) -> None:
-        """Update MCP state to completed for hook phases."""
         if self._has_mcp_state_manager():
             self._mcp_state_manager.update_stage_status("fast", "completed")
             self._mcp_state_manager.update_stage_status("comprehensive", "completed")
 
     async def _run_ai_agent_fixing_phase(self, options: OptionsProtocol) -> bool:
-        """Run AI agent fixing phase to analyze and fix collected failures."""
         self._update_mcp_status("ai_fixing", "running")
         self.logger.info("Starting AI agent fixing phase")
         self._log_debug_phase_start()
 
         try:
+            # If code cleaning is enabled and hasn't run yet, run it first
+            # to provide cleaner, more standardized code for the AI agents
+            if getattr(options, "clean", False) and not self._has_code_cleaning_run():
+                self.console.print(
+                    "\n[bold yellow]🤖 AI agents recommend running code cleaning first for better results...[/bold yellow]"
+                )
+                if self._run_code_cleaning_phase(options):
+                    # Run fast hooks sanity check after cleaning
+                    self._run_post_cleaning_fast_hooks(options)
+                    self._mark_code_cleaning_complete()
+
             agent_coordinator = self._setup_agent_coordinator()
             issues = await self._collect_issues_from_failures()
 
@@ -419,7 +465,6 @@ class WorkflowPipeline:
             return self._handle_fixing_phase_error(e)
 
     def _log_debug_phase_start(self) -> None:
-        """Log debug information for phase start."""
         if self._should_debug():
             self.debugger.log_workflow_phase(
                 "ai_agent_fixing",
@@ -428,7 +473,6 @@ class WorkflowPipeline:
             )
 
     def _setup_agent_coordinator(self) -> AgentCoordinator:
-        """Set up agent coordinator with proper context."""
         from crackerjack.agents.coordinator import AgentCoordinator
 
         agent_context = AgentContext(
@@ -441,7 +485,6 @@ class WorkflowPipeline:
         return agent_coordinator
 
     def _handle_no_issues_found(self) -> bool:
-        """Handle case when no issues are collected."""
         self.logger.info("No issues collected for AI agent fixing")
         self._update_mcp_status("ai_fixing", "completed")
         return True
@@ -449,7 +492,6 @@ class WorkflowPipeline:
     async def _process_fix_results(
         self, options: OptionsProtocol, fix_result: t.Any
     ) -> bool:
-        """Process fix results and verify success."""
         verification_success = await self._verify_fixes_applied(options, fix_result)
         success = fix_result.success and verification_success
 
@@ -462,7 +504,6 @@ class WorkflowPipeline:
         return success
 
     def _handle_successful_fixes(self, fix_result: t.Any) -> None:
-        """Handle successful fix results."""
         self.logger.info(
             "AI agents successfully fixed all issues and verification passed"
         )
@@ -472,10 +513,9 @@ class WorkflowPipeline:
     def _handle_failed_fixes(
         self, fix_result: t.Any, verification_success: bool
     ) -> None:
-        """Handle failed fix results."""
         if not verification_success:
             self.logger.warning(
-                "AI agent fixes did not pass verification - issues still exist"
+                "AI agent fixes did not pass verification-issues still exist"
             )
         else:
             self.logger.warning(
@@ -484,7 +524,6 @@ class WorkflowPipeline:
         self._update_mcp_status("ai_fixing", "failed")
 
     def _log_fix_counts_if_debugging(self, fix_result: t.Any) -> None:
-        """Log fix counts for debugging if debug mode is enabled."""
         if not self._should_debug():
             return
 
@@ -497,7 +536,6 @@ class WorkflowPipeline:
         self.debugger.log_hook_fixes(hook_fixes)
 
     def _log_debug_phase_completion(self, success: bool, fix_result: t.Any) -> None:
-        """Log debug information for phase completion."""
         if self._should_debug():
             self.debugger.log_workflow_phase(
                 "ai_agent_fixing",
@@ -510,7 +548,6 @@ class WorkflowPipeline:
             )
 
     def _handle_fixing_phase_error(self, error: Exception) -> bool:
-        """Handle errors during the fixing phase."""
         self.logger.exception(f"AI agent fixing phase failed: {error}")
         self.session.fail_task("ai_fixing", f"AI agent fixing failed: {error}")
         self._update_mcp_status("ai_fixing", "failed")
@@ -527,53 +564,67 @@ class WorkflowPipeline:
     async def _verify_fixes_applied(
         self, options: OptionsProtocol, fix_result: t.Any
     ) -> bool:
-        """Verify that AI agent fixes actually resolved the issues by re-running checks."""
         if not fix_result.fixes_applied:
-            return True  # No fixes were applied, nothing to verify
+            return True
 
         self.logger.info("Verifying AI agent fixes by re-running quality checks")
 
-        # Re-run the phases that previously failed to verify fixes
         verification_success = True
 
-        # Check if we need to re-run tests
-        if any("test" in fix.lower() for fix in fix_result.fixes_applied):
-            self.logger.info("Re-running tests to verify test fixes")
-            test_success = self.phases.run_testing_phase(options)
-            if not test_success:
-                self.logger.warning(
-                    "Test verification failed - test fixes did not work"
-                )
+        # Verify test fixes
+        if self._should_verify_test_fixes(fix_result.fixes_applied):
+            if not await self._verify_test_fixes(options):
+                verification_success = False
+
+        # Verify hook fixes
+        if self._should_verify_hook_fixes(fix_result.fixes_applied):
+            if not await self._verify_hook_fixes(options):
                 verification_success = False
 
-        # Check if we need to re-run comprehensive hooks
+        self._log_verification_result(verification_success)
+        return verification_success
+
+    def _should_verify_test_fixes(self, fixes_applied: list[str]) -> bool:
+        """Check if test fixes need verification."""
+        return any("test" in fix.lower() for fix in fixes_applied)
+
+    async def _verify_test_fixes(self, options: OptionsProtocol) -> bool:
+        """Verify test fixes by re-running tests."""
+        self.logger.info("Re-running tests to verify test fixes")
+        test_success = self.phases.run_testing_phase(options)
+        if not test_success:
+            self.logger.warning("Test verification failed-test fixes did not work")
+        return test_success
+
+    def _should_verify_hook_fixes(self, fixes_applied: list[str]) -> bool:
+        """Check if hook fixes need verification."""
         hook_fixes = [
             f
-            for f in fix_result.fixes_applied
+            for f in fixes_applied
             if "hook" not in f.lower()
             or "complexity" in f.lower()
             or "type" in f.lower()
         ]
-        if hook_fixes:
-            self.logger.info("Re-running comprehensive hooks to verify hook fixes")
-            hook_success = self.phases.run_comprehensive_hooks_only(options)
-            if not hook_success:
-                self.logger.warning(
-                    "Hook verification failed - hook fixes did not work"
-                )
-                verification_success = False
-
+        return bool(hook_fixes)
+
+    async def _verify_hook_fixes(self, options: OptionsProtocol) -> bool:
+        """Verify hook fixes by re-running comprehensive hooks."""
+        self.logger.info("Re-running comprehensive hooks to verify hook fixes")
+        hook_success = self.phases.run_comprehensive_hooks_only(options)
+        if not hook_success:
+            self.logger.warning("Hook verification failed-hook fixes did not work")
+        return hook_success
+
+    def _log_verification_result(self, verification_success: bool) -> None:
+        """Log the final verification result."""
         if verification_success:
             self.logger.info("All AI agent fixes verified successfully")
         else:
             self.logger.error(
-                "Verification failed - some fixes did not resolve the issues"
+                "Verification failed-some fixes did not resolve the issues"
             )
 
-        return verification_success
-
     async def _collect_issues_from_failures(self) -> list[Issue]:
-        """Collect issues from test and comprehensive hook failures."""
         issues: list[Issue] = []
 
         test_issues, test_count = self._collect_test_failure_issues()
@@ -587,7 +638,6 @@ class WorkflowPipeline:
         return issues
 
     def _collect_test_failure_issues(self) -> tuple[list[Issue], int]:
-        """Collect test failure issues and return count."""
         issues: list[Issue] = []
         test_count = 0
 
@@ -599,7 +649,7 @@ class WorkflowPipeline:
             test_count = len(test_failures)
             for i, failure in enumerate(
                 test_failures[:20],
-            ):  # Limit to prevent overload
+            ):
                 issue = Issue(
                     id=f"test_failure_{i}",
                     type=IssueType.TEST_FAILURE,
@@ -612,7 +662,6 @@ class WorkflowPipeline:
         return issues, test_count
 
     def _collect_hook_failure_issues(self) -> tuple[list[Issue], int]:
-        """Collect hook failure issues and return count."""
         issues: list[Issue] = []
         hook_count = 0
 
@@ -625,7 +674,6 @@ class WorkflowPipeline:
         return issues, hook_count
 
     def _process_hook_results(self, hook_results: t.Any) -> tuple[list[Issue], int]:
-        """Process hook results and extract issues."""
         issues: list[Issue] = []
         hook_count = 0
 
@@ -640,17 +688,14 @@ class WorkflowPipeline:
         return issues, hook_count
 
     def _is_hook_result_failed(self, result: t.Any) -> bool:
-        """Check if hook result indicates failure."""
         return result.status in ("failed", "error", "timeout")
 
     def _extract_issues_from_hook_result(self, result: t.Any) -> list[Issue]:
-        """Extract issues from a single hook result."""
         if result.issues_found:
             return self._create_specific_issues_from_hook_result(result)
         return [self._create_generic_issue_from_hook_result(result)]
 
     def _create_specific_issues_from_hook_result(self, result: t.Any) -> list[Issue]:
-        """Create specific issues from hook result with detailed information."""
         issues: list[Issue] = []
         hook_context = f"{result.name}: "
 
@@ -661,7 +706,6 @@ class WorkflowPipeline:
         return issues
 
     def _create_generic_issue_from_hook_result(self, result: t.Any) -> Issue:
-        """Create a generic issue for hook failure without specific details."""
         issue_type = self._determine_hook_issue_type(result.name)
         return Issue(
             id=f"hook_failure_{result.name}",
@@ -672,13 +716,16 @@ class WorkflowPipeline:
         )
 
     def _determine_hook_issue_type(self, hook_name: str) -> IssueType:
-        """Determine issue type based on hook name."""
         formatting_hooks = {
             "trailing-whitespace",
             "end-of-file-fixer",
             "ruff-format",
             "ruff-check",
         }
+
+        if hook_name == "validate-regex-patterns":
+            return IssueType.REGEX_VALIDATION
+
         return (
             IssueType.FORMATTING
             if hook_name in formatting_hooks
@@ -686,7 +733,6 @@ class WorkflowPipeline:
         )
 
     def _fallback_to_session_tracker(self) -> tuple[list[Issue], int]:
-        """Fallback to session tracker if hook manager fails."""
         issues: list[Issue] = []
         hook_count = 0
 
@@ -702,14 +748,12 @@ class WorkflowPipeline:
         return issues, hook_count
 
     def _is_failed_hook_task(self, task_data: t.Any, task_id: str) -> bool:
-        """Check if a task is a failed hook task."""
         return task_data.status == "failed" and task_id in (
             "fast_hooks",
             "comprehensive_hooks",
         )
 
     def _process_hook_failure(self, task_id: str, task_data: t.Any) -> list[Issue]:
-        """Process a single hook failure and return corresponding issues."""
         error_msg = getattr(task_data, "error_message", "Unknown error")
         specific_issues = self._parse_hook_error_details(task_id, error_msg)
 
@@ -719,7 +763,6 @@ class WorkflowPipeline:
         return [self._create_generic_hook_issue(task_id, error_msg)]
 
     def _create_generic_hook_issue(self, task_id: str, error_msg: str) -> Issue:
-        """Create a generic issue for unspecific hook failures."""
         issue_type = IssueType.FORMATTING if "fast" in task_id else IssueType.TYPE_ERROR
         return Issue(
             id=f"hook_failure_{task_id}",
@@ -730,128 +773,138 @@ class WorkflowPipeline:
         )
 
     def _parse_hook_error_details(self, task_id: str, error_msg: str) -> list[Issue]:
-        """Parse specific hook failure details to create targeted issues."""
+        """Parse hook error details and create specific issues."""
         issues: list[Issue] = []
 
-        # For comprehensive hooks, parse specific tool failures
         if task_id == "comprehensive_hooks":
-            # Check for complexipy failures (complexity violations)
-            if "complexipy" in error_msg.lower():
-                issues.append(
-                    Issue(
-                        id="complexipy_violation",
-                        type=IssueType.COMPLEXITY,
-                        severity=Priority.HIGH,
-                        message="Code complexity violation detected by complexipy",
-                        stage="comprehensive",
-                    )
-                )
+            issues.extend(self._parse_comprehensive_hook_errors(error_msg))
+        elif task_id == "fast_hooks":
+            issues.append(self._create_fast_hook_issue())
 
-            # Check for pyright failures (type errors)
-            if "pyright" in error_msg.lower():
-                issues.append(
-                    Issue(
-                        id="pyright_type_error",
-                        type=IssueType.TYPE_ERROR,
-                        severity=Priority.HIGH,
-                        message="Type checking errors detected by pyright",
-                        stage="comprehensive",
-                    )
-                )
+        return issues
 
-            # Check for bandit failures (security issues)
-            if "bandit" in error_msg.lower():
-                issues.append(
-                    Issue(
-                        id="bandit_security_issue",
-                        type=IssueType.SECURITY,
-                        severity=Priority.HIGH,
-                        message="Security vulnerabilities detected by bandit",
-                        stage="comprehensive",
-                    )
-                )
+    def _parse_comprehensive_hook_errors(self, error_msg: str) -> list[Issue]:
+        """Parse comprehensive hook error messages and create specific issues."""
+        issues: list[Issue] = []
+        error_lower = error_msg.lower()
 
-            # Check for refurb failures (code quality issues)
-            if "refurb" in error_msg.lower():
-                issues.append(
-                    Issue(
-                        id="refurb_quality_issue",
-                        type=IssueType.PERFORMANCE,  # Use PERFORMANCE as closest match for refurb issues
-                        severity=Priority.MEDIUM,
-                        message="Code quality issues detected by refurb",
-                        stage="comprehensive",
-                    )
-                )
+        # Check each error type
+        complexity_issue = self._check_complexity_error(error_lower)
+        if complexity_issue:
+            issues.append(complexity_issue)
 
-            # Check for vulture failures (dead code)
-            if "vulture" in error_msg.lower():
-                issues.append(
-                    Issue(
-                        id="vulture_dead_code",
-                        type=IssueType.DEAD_CODE,
-                        severity=Priority.MEDIUM,
-                        message="Dead code detected by vulture",
-                        stage="comprehensive",
-                    )
-                )
+        type_error_issue = self._check_type_error(error_lower)
+        if type_error_issue:
+            issues.append(type_error_issue)
 
-        elif task_id == "fast_hooks":
-            # Fast hooks are typically formatting issues
-            issues.append(
-                Issue(
-                    id="fast_hooks_formatting",
-                    type=IssueType.FORMATTING,
-                    severity=Priority.LOW,
-                    message="Code formatting issues detected",
-                    stage="fast",
-                )
-            )
+        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)
 
         return issues
 
+    def _check_complexity_error(self, error_lower: str) -> Issue | None:
+        """Check for complexity errors and create issue if found."""
+        if "complexipy" in error_lower or "c901" in error_lower:
+            return Issue(
+                id="complexity_violation",
+                type=IssueType.COMPLEXITY,
+                severity=Priority.HIGH,
+                message="Code complexity violation detected",
+                stage="comprehensive",
+            )
+        return None
+
+    def _check_type_error(self, error_lower: str) -> Issue | None:
+        """Check for type errors and create issue if found."""
+        if "pyright" in error_lower:
+            return Issue(
+                id="pyright_type_error",
+                type=IssueType.TYPE_ERROR,
+                severity=Priority.HIGH,
+                message="Type checking errors detected by pyright",
+                stage="comprehensive",
+            )
+        return None
+
+    def _check_security_error(self, error_lower: str) -> Issue | None:
+        """Check for security errors and create issue if found."""
+        if "bandit" in error_lower:
+            return Issue(
+                id="bandit_security_issue",
+                type=IssueType.SECURITY,
+                severity=Priority.HIGH,
+                message="Security vulnerabilities detected by bandit",
+                stage="comprehensive",
+            )
+        return None
+
+    def _check_performance_error(self, error_lower: str) -> Issue | None:
+        """Check for performance errors and create issue if found."""
+        if "refurb" in error_lower:
+            return Issue(
+                id="refurb_quality_issue",
+                type=IssueType.PERFORMANCE,
+                severity=Priority.MEDIUM,
+                message="Code quality issues detected by refurb",
+                stage="comprehensive",
+            )
+        return None
+
+    def _check_dead_code_error(self, error_lower: str) -> Issue | None:
+        """Check for dead code errors and create issue if found."""
+        if "vulture" in error_lower:
+            return Issue(
+                id="vulture_dead_code",
+                type=IssueType.DEAD_CODE,
+                severity=Priority.MEDIUM,
+                message="Dead code detected by vulture",
+                stage="comprehensive",
+            )
+        return None
+
+    def _check_regex_validation_error(self, error_lower: str) -> Issue | None:
+        """Check for regex validation errors and create issue if found."""
+        regex_keywords = ("raw regex", "regex pattern", r"\g<", "replacement")
+        if "validate-regex-patterns" in error_lower or any(
+            keyword in error_lower for keyword in regex_keywords
+        ):
+            return Issue(
+                id="regex_validation_failure",
+                type=IssueType.REGEX_VALIDATION,
+                severity=Priority.HIGH,
+                message="Unsafe regex patterns detected by validate-regex-patterns",
+                stage="fast",
+            )
+        return None
+
+    def _create_fast_hook_issue(self) -> Issue:
+        """Create an issue for fast hook errors."""
+        return Issue(
+            id="fast_hooks_formatting",
+            type=IssueType.FORMATTING,
+            severity=Priority.LOW,
+            message="Code formatting issues detected",
+            stage="fast",
+        )
+
     def _parse_issues_for_agents(self, issue_strings: list[str]) -> list[Issue]:
-        """Parse string issues into structured Issue objects for AI agents."""
         issues: list[Issue] = []
 
         for i, issue_str in enumerate(issue_strings):
-            # Determine issue type from content patterns
-            issue_type = IssueType.FORMATTING
-            priority = Priority.MEDIUM
-
-            if any(
-                keyword in issue_str.lower()
-                for keyword in ("type", "annotation", "pyright")
-            ):
-                issue_type = IssueType.TYPE_ERROR
-                priority = Priority.HIGH
-            elif any(
-                keyword in issue_str.lower()
-                for keyword in ("security", "bandit", "hardcoded")
-            ):
-                issue_type = IssueType.SECURITY
-                priority = Priority.HIGH
-            elif any(
-                keyword in issue_str.lower() for keyword in ("complexity", "complexipy")
-            ):
-                issue_type = IssueType.COMPLEXITY
-                priority = Priority.HIGH
-            elif any(
-                keyword in issue_str.lower()
-                for keyword in ("unused", "dead", "vulture")
-            ):
-                issue_type = IssueType.DEAD_CODE
-                priority = Priority.MEDIUM
-            elif any(
-                keyword in issue_str.lower()
-                for keyword in ("performance", "refurb", "furb")
-            ):
-                issue_type = IssueType.PERFORMANCE
-                priority = Priority.MEDIUM
-            elif any(
-                keyword in issue_str.lower() for keyword in ("import", "creosote")
-            ):
-                issue_type = IssueType.IMPORT_ERROR
-                priority = Priority.MEDIUM
+            issue_type, priority = self._classify_issue(issue_str)
 
             issue = Issue(
                 id=f"parsed_issue_{i}",
@@ -864,10 +917,80 @@ class WorkflowPipeline:
 
         return issues
 
+    def _classify_issue(self, issue_str: str) -> tuple[IssueType, Priority]:
+        """Classify an issue string to determine its type and priority."""
+        issue_lower = issue_str.lower()
+
+        # Check high-priority issues first
+        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
+
+        # Check medium-priority issues
+        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
+
+        # Default to formatting issue
+        return IssueType.FORMATTING, Priority.MEDIUM
+
+    def _is_type_error(self, issue_lower: str) -> bool:
+        """Check if issue is related to type errors."""
+        return any(
+            keyword in issue_lower for keyword in ("type", "annotation", "pyright")
+        )
+
+    def _is_security_issue(self, issue_lower: str) -> bool:
+        """Check if issue is related to security."""
+        return any(
+            keyword in issue_lower for keyword in ("security", "bandit", "hardcoded")
+        )
+
+    def _is_complexity_issue(self, issue_lower: str) -> bool:
+        """Check if issue is related to code complexity."""
+        return any(
+            keyword in issue_lower
+            for keyword in ("complexity", "complexipy", "c901", "too complex")
+        )
+
+    def _is_regex_validation_issue(self, issue_lower: str) -> bool:
+        """Check if issue is related to regex validation."""
+        return any(
+            keyword in issue_lower
+            for keyword in (
+                "regex",
+                "pattern",
+                "validate-regex-patterns",
+                r"\g<",
+                "replacement",
+            )
+        )
+
+    def _is_dead_code_issue(self, issue_lower: str) -> bool:
+        """Check if issue is related to dead code."""
+        return any(keyword in issue_lower for keyword in ("unused", "dead", "vulture"))
+
+    def _is_performance_issue(self, issue_lower: str) -> bool:
+        """Check if issue is related to performance."""
+        return any(
+            keyword in issue_lower for keyword in ("performance", "refurb", "furb")
+        )
+
+    def _is_import_error(self, issue_lower: str) -> bool:
+        """Check if issue is related to import errors."""
+        return any(keyword in issue_lower for keyword in ("import", "creosote"))
+
     def _log_failure_counts_if_debugging(
         self, test_count: int, hook_count: int
     ) -> None:
-        """Log failure counts if debugging is enabled."""
         if self._should_debug():
             self.debugger.log_test_failures(test_count)
             self.debugger.log_hook_failures(hook_count)
@@ -881,14 +1004,17 @@ class WorkflowOrchestrator:
         dry_run: bool = False,
         web_job_id: str | None = None,
         verbose: bool = False,
+        debug: bool = False,
     ) -> None:
         self.console = console or Console(force_terminal=True)
         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
 
         from crackerjack.models.protocols import (
+            ConfigMergeServiceProtocol,
             FileSystemInterface,
             GitInterface,
             HookManager,
@@ -896,9 +1022,14 @@ class WorkflowOrchestrator:
             TestManagerProtocol,
         )
 
-        from .container import create_container
+        # Initialize logging first so container creation respects log levels
+        self._initialize_logging()
+
+        self.logger = get_logger("crackerjack.orchestrator")
+
+        from .enhanced_container import create_enhanced_container
 
-        self.container = create_container(
+        self.container = create_enhanced_container(
             console=self.console,
             pkg_path=self.pkg_path,
             dry_run=self.dry_run,
@@ -915,6 +1046,7 @@ class WorkflowOrchestrator:
             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),
         )
 
         self.pipeline = WorkflowPipeline(
@@ -924,10 +1056,6 @@ class WorkflowOrchestrator:
             phases=self.phases,
         )
 
-        self.logger = get_logger("crackerjack.orchestrator")
-
-        self._initialize_logging()
-
     def _initialize_logging(self) -> None:
         from crackerjack.services.log_manager import get_log_manager
 
@@ -935,9 +1063,15 @@ class WorkflowOrchestrator:
         session_id = getattr(self, "web_job_id", None) or str(int(time.time()))[:8]
         debug_log_file = log_manager.create_debug_log_file(session_id)
 
-        setup_structured_logging(log_file=debug_log_file)
+        # Set log level based on verbosity - DEBUG only in verbose or debug mode
+        log_level = "DEBUG" if (self.verbose or self.debug) else "INFO"
+        setup_structured_logging(
+            level=log_level, json_output=False, log_file=debug_log_file
+        )
 
-        self.logger.info(
+        # Use a temporary logger for the initialization message
+        temp_logger = get_logger("crackerjack.orchestrator.init")
+        temp_logger.debug(
             "Structured logging initialized",
             log_file=str(debug_log_file),
             log_directory=str(log_manager.log_dir),