This sub-workflow provides an aggressive, thorough, and all-encompassing investigation process for technical analysis when creating GitHub issues. It employs methods from the issue-investigator mode to deeply analyze the codebase and formulate comprehensive technical solutions. This workflow is designed to produce scoped issues that can be used in automated fix workflows. Create Investigation Plan When technical analysis is requested, immediately create a comprehensive todo list to track the investigation progress. [ ] Extract keywords from the issue description [ ] Perform initial broad codebase search [ ] Analyze search results and identify key components [ ] Deep dive into relevant files and implementations [ ] Form initial hypothesis about the issue/feature [ ] Attempt to disprove hypothesis through further investigation [ ] Identify all affected files and dependencies [ ] Map out the complete implementation approach [ ] Document technical risks and edge cases [ ] Formulate comprehensive technical solution [ ] Create detailed acceptance criteria [ ] Prepare technical analysis summary ]]> Extract all relevant keywords, concepts, and technical terms from the issue description. Be exhaustive - include function names, error messages, feature names, and related concepts. Identify primary technical concepts Extract error messages or specific symptoms Note any mentioned file paths or components List related features or functionality Include synonyms and related terms Mark "Extract keywords from the issue description" as complete Perform multiple rounds of codebase searches, starting broad and progressively narrowing based on findings. This is an aggressive, exhaustive search process. Use codebase_search with all extracted keywords to get an overview of relevant code. [Combined keywords from extraction phase] ]]> Based on initial results, identify key components and search for: - Related class/function definitions - Import statements and dependencies - Configuration files - Test files that might reveal expected behavior Search for specific implementation details: - Error handling patterns - State management - API endpoints or routes - Database queries or models - UI components and their interactions Look for: - Edge cases in the code - Integration points with other systems - Configuration options that affect behavior - Feature flags or conditional logic Update search-related todos as each iteration completes Thoroughly analyze all relevant files discovered during the search phase. Use list_code_definition_names to understand file structure Read complete files to understand full context Trace execution paths through the code Identify all dependencies and imports Map relationships between components Document findings including: - File paths and their purposes - Key functions and their responsibilities - Data flow through the system - External dependencies - Potential impact areas Mark file analysis todos as complete Form a comprehensive hypothesis about the issue or feature implementation. Identify the most likely root cause Trace the bug through the execution path Determine why the current implementation fails Consider environmental factors Identify the optimal integration points Determine required architectural changes Plan the implementation approach Consider scalability and maintainability Mark hypothesis formation as complete Aggressively attempt to disprove the hypothesis by searching for contradictory evidence. Look for similar features implemented differently Check for deprecated code that might interfere Search for configuration that could change behavior Look for environment-specific code paths Find existing tests that might contradict hypothesis Look for test cases that reveal edge cases Search for comments explaining design decisions Look for TODO or FIXME comments related to the area If hypothesis is disproven, return to search phase with new insights. If hypothesis stands, proceed to solution formulation. Update hypothesis validation status Create a comprehensive technical solution with extreme detail.

- Exact files to modify with line numbers - New files to create with full paths - Specific code changes required - Order of implementation steps - Migration strategy if needed

- All files that import affected code - API contracts that must be maintained - Database schema changes if any - Configuration changes required - Documentation updates needed

- Unit tests to add or modify - Integration tests required - Edge cases to test - Performance testing needs - Manual testing scenarios

- Breaking changes identified - Performance implications - Security considerations - Backward compatibility issues - Rollback strategy

Mark solution formulation as complete Create extremely detailed acceptance criteria that can guide automated implementation. Each criterion must be independently testable Include both positive and negative test cases Specify exact error messages and codes Define performance thresholds where applicable Mark acceptance criteria creation as complete All keywords extracted and searched Multiple search iterations completed All relevant files analyzed Hypothesis formed and validated Comprehensive solution documented Acceptance criteria defined All risks and edge cases identified Technical analysis formatted for issue Mark all investigation todos as complete and update the main workflow todo list