@exaudeus/workrail 0.1.0 → 0.1.2

package/workflows/mr-review-workflow.json

@@ -1,7 +1,7 @@
 {
   "id": "mr-review-workflow",
   "name": "Adaptive MR Review Workflow",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "An adaptive workflow to guide an AI agent in performing a comprehensive code review. It adjusts its rigor based on MR complexity and includes checkpoints for architectural and self-critique to provide deep, actionable feedback.",
   "preconditions": [
     "User has the full code diff accessible (e.g., as text in a file).",
@@ -9,17 +9,21 @@
     "The agent has access to file-reading tools."
   ],
   "metaGuidance": [
-    "The ultimate goal is to assist, not replace, a human reviewer.",
-    "All feedback should be constructive and actionable.",
+    "The ultimate goal is to assist, not replace, a human reviewer. The human owns the final merge decision.",
+    "All feedback should be constructive and actionable. Explain the 'why' behind suggestions.",
+    "The goal is continuous improvement, not perfection. Approve changes that are 'better' to maintain velocity.",
+    "Foster a blameless culture of collective ownership. The code is a shared asset.",
+    "Use prefixes like 'Nit:' for non-blocking, minor suggestions to keep focus on important issues.",
+    "Embrace small, single-purpose pull requests for faster, more thorough reviews.",
     "When citing issues, always try to provide specific file paths and line numbers from the diff.",
     "Maintain the persona of a helpful, collaborative senior engineer.",
-    "If at any point you determine that a crucial piece of information is missing to complete your analysis, you must pause. State what information you need, why it is necessary, and ask the user to provide it."
+    "If at any point you determine that a crucial piece of information is missing, you must pause and ask the user to provide it."
   ],
   "steps": [
     {
       "id": "phase-0-triage",
       "title": "Phase 0: Triage & Review Focus",
-      "prompt": "To begin the Merge Request review, please provide the full context below and classify the MR's complexity. This will tailor the depth of the review.\n\n**1. MR Context:**\n* **MR Title/Purpose:** [User provides the title and a brief description of its purpose.]\n* **Related Ticket(s):** [User provides ticket numbers or links.]\n* **Key Requirements/Acceptance Criteria:** [User lists key requirements from the ticket(s).]\n\n**2. Code Diff:**\n[User pastes the full `git diff` output or provides a path to a file containing the diff.]\n\n**3. Complexity Classification & Focus:**\n* **Classification:** Please choose one: **[Trivial]**, **[Standard]**, or **[High-Risk]**.\n* **Areas of Focus (Optional):** Are there specific areas you want me to pay close attention to? (e.g., 'performance implications', 'API design', 'data integrity').",
+      "prompt": "To begin the Merge Request review, please provide the full context below and classify the MR's complexity. This will tailor the depth of the review.\n\n**1. MR Context:**\n* **MR Title/Purpose:** [User provides the title and a brief description of its purpose.]\n* **Related Ticket(s):** [User provides ticket numbers or links.]\n* **Key Requirements/Acceptance Criteria:** [User lists key requirements from the ticket(s).]\n\n**2. Code Diff:**\n[User pastes the full `git diff` output or provides a path to a file containing the diff.]\n\n**3. Complexity Classification & Focus:**\n* **Classification:** Please choose one: **[Trivial]**, **[Standard]**, or **[High-Risk]**.\n* **PR Size:** Is this a small, focused change (<400 lines)? If not, does it have a single, clear purpose?\n* **Areas of Focus (Optional):** Are there specific areas you want me to pay close attention to? (e.g., 'performance implications', 'API design', 'data integrity').",
       "agentRole": "You are a code review coordinator and triage specialist with expertise in assessing merge request complexity and risk. Your role is to efficiently classify reviews and establish appropriate focus areas to ensure the right level of scrutiny for each change.",
       "guidance": [
         "**[Trivial]:** For minor fixes (typos, docs). This will run a condensed, single-phase review.",
@@ -35,24 +39,55 @@
       "guidance": [
         "This is a critical sanity check. If the agent's summary is incorrect, correct it now to prevent a flawed review. This step is skipped for 'Trivial' reviews."
       ],
+      "runCondition": { "var": "complexity", "not_equals": "Trivial" },
       "requireConfirmation": true
     },
     {
-      "id": "phase-2-detailed-analysis",
-      "title": "Phase 2: In-Depth Line-by-Line Analysis",
-      "prompt": "My goal is to perform a detailed, line-by-line analysis of the code diff, guided by the checklist below and focusing on any specific areas you requested. I will provide specific examples and line numbers for my findings.\n\n**Detailed Analysis Checklist:**\n1.  **Functionality & Correctness:** Does the code implement the requirements? Are there logical flaws or unhandled edge cases?\n2.  **Readability & Maintainability:** How is the clarity, naming, and complexity? Are comments sufficient and accurate?\n3.  **Design & Architecture:** Does the code align with existing patterns? Does it introduce risky dependencies or side effects?\n4.  **Best Practices & Conventions:** Does the code follow language-specific best practices and avoid anti-patterns?\n5.  **Error Handling:** Is error handling robust and appropriate?\n6.  **Performance:** Are there any obvious performance bottlenecks?\n7.  **Code Duplication:** Is there significant duplicated code?\n8.  **Security:** Are there any potential security vulnerabilities introduced (e.g., injection, improper handling of sensitive data)?\n9.  **Debug Statements:** Are there leftover debugging statements (`print`, `console.log`)?",
-      "agentRole": "You are a meticulous senior engineer specializing in detailed code quality analysis. Your expertise lies in systematically examining code for correctness, maintainability, security, and performance issues. You excel at providing specific, actionable feedback with clear examples and line references.",
-      "guidance": [
-        "The agent will now perform the most time-consuming part of the review. The thoroughness of this checklist helps catch a wide variety of issues."
-      ]
+      "id": "phase-1-context-setup",
+      "title": "Phase 1: Initializing Analysis State",
+      "prompt": "Initializing state for progressive depth analysis. Setting analysisDepth = 1, analysisComplete = false, and majorIssuesFound = false.",
+      "agentRole": "You are a state manager preparing the workflow for an iterative review process.",
+      "guidance": ["This is an automated step to prepare for the analysis loop."],
+      "runCondition": { "var": "complexity", "not_equals": "Trivial" }
     },
     {
-      "id": "phase-2b-holistic-review",
-      "title": "Phase 2b: Holistic Architectural Review",
-      "prompt": "Now, I will step back from the line-by-line details to assess the bigger picture.\n\nMy goal is to answer the following high-level questions:\n1.  **Simplicity & Approach:** Is this the simplest and most effective approach to solving the problem? Could the same outcome have been achieved more cleanly or with less new code?\n2.  **Precedent:** Does this change set a good or bad precedent for future development in this codebase?\n3.  **Strategic Alignment:** Does this change feel aligned with the overall architecture, or does it feel like a temporary 'hack' or a one-off solution?",
-      "agentRole": "You are a principal software architect with expertise in system design and long-term codebase evolution. Your role is to evaluate changes from a strategic perspective, considering architectural alignment, precedent setting, and the broader impact on system maintainability and scalability.",
-      "guidance": [
-        "This step prevents 'checklist tunnel vision' and encourages the agent to provide strategic, architectural feedback, which is often the most valuable."
+      "id": "phase-1a-llm-context-gathering",
+      "title": "Phase 1a: Comprehensive Context Gathering",
+      "prompt": "To perform a thorough review, I need more than just the code diff. Please provide the following:\n\n1. **Business Context:** Paste the full text of the associated Jira/GitHub ticket, including the requirements and acceptance criteria. This helps me validate the 'why' behind the change.\n2. **Technical Context:** If this change relies on other parts of the codebase, please provide the relevant code snippets or file contents. Also, include any relevant architectural diagrams or coding standards documents.\n\nI will synthesize this information to build a comprehensive context for my review.",
+      "agentRole": "You are a context-aware analyst ensuring you have all necessary information before starting a deep review.",
+      "guidance": ["A high-quality review depends on high-quality context. The more information provided here, the more accurate the review will be."],
+      "runCondition": { "var": "complexity", "not_equals": "Trivial" },
+      "requireConfirmation": true
+    },
+    {
+      "id": "phase-2-depth-analysis-loop",
+      "type": "loop",
+      "title": "Phase 2: Progressive Depth Analysis",
+      "runCondition": { "var": "complexity", "not_equals": "Trivial" },
+      "loop": {
+        "type": "until",
+        "condition": { "var": "analysisComplete", "equals": true },
+        "maxIterations": 3,
+        "iterationVar": "analysisDepth"
+      },
+      "body": [
+        {
+          "id": "perform-analysis-pass",
+          "title": "Analysis Pass {{analysisDepth}} of 3",
+          "prompt": "Act as a Senior Staff Engineer. Your task is to review the code based on the checklist for the current analysis depth. Think step-by-step.\n\n**Current Depth: {{analysisDepth}}**\n\n**Checklist:**\n* **Depth 1 (Basic Scan):** Check for style guide violations, simple bugs (e.g., typos, unused variables), and common security vulnerabilities (OWASP Top 10).\n* **Depth 2 (Standard Review):** Check for logical errors, edge cases, adherence to SOLID principles, and maintainability issues.\n* **Depth 3 (Deep Architectural Review):** Check for alignment with system architecture, long-term impact, performance bottlenecks, and dependency risks.\n\n**Instructions:**\n1.  **Summarize Focus:** State which depth level you are on and what you will focus on.\n2.  **Analyze:** Perform the review based on the checklist for depth {{analysisDepth}}.\n3.  **List Findings:** Document your findings, categorizing them as 'Critical', 'Major', or 'Minor'.\n4.  **Set Flag:** If you find any 'Critical' or 'Major' issues, set the context variable `majorIssuesFound = true`.",
+          "agentRole": "You are a Senior Staff Engineer performing a structured, multi-pass code review with increasing levels of scrutiny.",
+          "guidance": [
+            "At each depth, focus only on the items in that checklist.",
+            "Use Chain-of-Thought reasoning to explain your findings."
+          ]
+        },
+        {
+          "id": "check-analysis-completion",
+          "title": "Check Analysis Completion",
+          "prompt": "Checking if the analysis is complete. If no 'Major' or 'Critical' issues were found in the last pass, or if we have reached the maximum depth (3), I will set `analysisComplete = true` to exit the loop. Otherwise, I will increment the `analysisDepth` and continue to the next level of review.",
+          "agentRole": "You are an automated process controller determining whether to deepen the analysis or conclude this phase.",
+          "guidance": ["This step determines the exit condition for the progressive depth loop."]
+        }
       ]
     },
     {
@@ -62,15 +97,28 @@
       "agentRole": "You are a software quality engineer specializing in testing strategy and impact analysis. Your expertise includes identifying testing gaps, documentation requirements, and potential breaking changes that could affect system stability or user experience.",
       "guidance": [
         "Assessing test coverage is critical. A lack of tests for new logic is often a 'Major' or 'Critical' concern."
-      ]
+      ],
+      "runCondition": { "var": "complexity", "not_equals": "Trivial" }
     },
     {
-      "id": "phase-4-summary",
-      "title": "Phase 4: Final Summary & Structured Feedback",
-      "prompt": "My goal is to consolidate all findings into a final, actionable report.\n\nFirst, I will perform a **Devil's Advocate Self-Critique:** I will briefly review my own findings. Are any of my 'Major' concerns actually minor preferences? Conversely, is there a pattern among my 'Minor' suggestions that points to a larger, unstated problem? I will state if this check changed my perspective.\n\nNext, I will provide the final report in this structure:\n1.  **Overall MR Assessment:** A 2-3 sentence qualitative summary of the MR.\n2.  **Key Positive Aspects:** 2-3 highlights of what was done well.\n3.  **Main Areas of Concern (Categorized):**\n    * **Critical (Blocking issues, potential bugs):**\n    * **Major (Important design flaws, missing core tests):**\n    * **Minor/Suggestions (Readability, best practices):**\n4.  **Questions for the Author:** A list of specific, clarifying questions.\n5.  **Actionable Recommendations:** Concrete suggestions for the most important issues.",
-      "agentRole": "You are an experienced code review facilitator and technical communicator specializing in synthesizing complex technical analysis into clear, actionable feedback. Your strength is balancing critical assessment with constructive guidance, ensuring feedback is both thorough and helpful to developers.",
-      "guidance": [
-        "The final, categorized summary is designed to be copied directly into a GitHub, GitLab, or other code review tool to provide clear and structured feedback to the MR author."
+      "id": "phase-4-refinement-loop",
+      "type": "loop",
+      "title": "Phase 4: Iterative Summary & Refinement",
+      "runCondition": { "var": "complexity", "not_equals": "Trivial" },
+      "loop": {
+        "type": "until",
+        "condition": { "var": "critiqueComplete", "equals": true },
+        "maxIterations": 2,
+        "iterationVar": "critiquePass"
+      },
+      "body": [
+        {
+          "id": "generate-summary-and-critique",
+          "title": "Generate Summary & Self-Critique (Pass {{critiquePass}})",
+          "prompt": "Consolidate all findings into a final, actionable report.\n\n**1. Devil's Advocate Self-Critique:**\nReview your own findings. Are any of your 'Major' concerns actually minor preferences? Is there a pattern among 'Minor' suggestions that points to a larger problem? Does this critique reveal a fundamental flaw in your analysis that requires another pass?\n\n**2. Final Report:**\n* **Overall Assessment:** A 2-3 sentence summary.\n* **Key Positive Aspects:** Highlights of what was done well.\n* **Concerns (Categorized):** Critical, Major, and Minor/Nit.\n* **Questions for Author:** Clarifying questions.\n* **Actionable Recommendations:** Concrete suggestions.\n\n**3. Set Flag:** Based on your self-critique, set `critiqueComplete = true` if the summary is robust, or `critiqueComplete = false` if you need one more pass to refine it.",
+          "agentRole": "You are a facilitator synthesizing feedback and performing a self-critique to ensure the final report is balanced and high-quality.",
+          "guidance": ["Use 'Nit:' for minor issues. Balance criticism with praise. The goal is a collaborative and constructive report."]
+        }
       ]
     },
     {
@@ -80,7 +128,8 @@
       "agentRole": "You are an efficient code reviewer specializing in rapid assessment of low-risk changes. Your role is to quickly validate that trivial changes are safe and appropriate while avoiding over-analysis of simple modifications.",
       "guidance": [
         "This is the condensed summary for 'Trivial' reviews. The agent skips all other analytical steps and provides a simple confirmation for straightforward changes."
-      ]
+      ],
+      "runCondition": { "var": "complexity", "equals": "Trivial" }
     }
   ]
 } 

package/workflows/systemic-bug-investigation-with-loops.json

@@ -0,0 +1,423 @@
+{
+    "id": "systematic-bug-investigation-with-loops",
+    "name": "Systematic Bug Investigation Workflow",
+    "version": "1.0.0",
+    "description": "A comprehensive workflow for systematic bug and failing test investigation that prevents LLMs from jumping to conclusions. Enforces thorough evidence gathering, hypothesis formation, debugging instrumentation, and validation to achieve near 100% certainty about root causes. This workflow does NOT fix bugs - it produces detailed diagnostic writeups that enable effective fixing by providing complete understanding of what is happening, why it's happening, and supporting evidence.",
+    "clarificationPrompts": [
+        "What type of system is this? (web app, mobile app, backend service, desktop app, etc.)",
+        "How consistently can you reproduce this bug? (always reproducible, sometimes reproducible, rarely reproducible)",
+        "What was the last known working version or state if applicable?",
+        "Are there any time constraints or urgency factors for this investigation?",
+        "What level of system access do you have? (full codebase, limited access, production logs only)",
+        "Do you have preferences for handling large log volumes? (sub-chat analysis, inline summaries only, or no preference for automatic decision)"
+    ],
+    "preconditions": [
+        "User has identified a specific bug or failing test to investigate",
+        "Agent has access to codebase analysis tools (grep, file readers, etc.)",
+        "Agent has access to build/test execution tools for the project type",
+        "User can provide error messages, stack traces, or test failure output",
+        "Bug is reproducible with specific steps or a minimal test case"
+    ],
+    "metaGuidance": [
+        "INVESTIGATION DISCIPLINE: Never propose fixes or solutions until Phase 6 (Comprehensive Diagnostic Writeup). Focus entirely on systematic evidence gathering and analysis.",
+        "HYPOTHESIS RIGOR: All hypotheses must be based on concrete evidence from code analysis with quantified scoring (1-10 scales). Maximum 5 hypotheses per investigation.",
+        "DEBUGGING INSTRUMENTATION: Always implement debugging mechanisms before running tests - logs, print statements, or test modifications that will provide evidence.",
+        "EVIDENCE THRESHOLD: Require minimum 3 independent sources of evidence before confirming any hypothesis. Use objective verification criteria.",
+        "SYSTEMATIC PROGRESSION: Complete each investigation phase fully before proceeding. Each phase builds critical context for the next with structured documentation.",
+        "CONFIDENCE CALIBRATION: Use mathematical confidence framework with 9.0/10 minimum threshold. Actively challenge conclusions with adversarial analysis.",
+        "UNCERTAINTY ACKNOWLEDGMENT: Explicitly document all remaining unknowns and their potential impact. No subjective confidence assessments.",
+        "THOROUGHNESS: For complex bugs, recursively analyze dependencies and internals of identified components to ensure full picture.",
+        "TEST INTEGRATION: Leverage existing tests to validate hypotheses where possible.",
+        "LOG ENHANCEMENTS: Include class/function names. For repetitive logs, implement deduplication by tracking counts ('x[count]') and grouping related sequential logs for readability. See Phase 3 for detailed implementation patterns and examples.",
+        "LOG ANALYSIS OFFLOADING: For voluminous logs (>500 lines), offload analysis to sub-chats with structured prompts. See Phase 4 for detailed sub-analysis implementation.",
+        "RECURSION DEPTH: Limit recursive analysis to 3 levels deep to prevent analysis paralysis while ensuring thoroughness.",
+        "INVESTIGATION BOUNDS: If investigation exceeds 20 steps or 4 hours without root cause, pause and reassess approach with user.",
+        "AUTOMATION LEVELS: High=auto-approve >8.0 confidence decisions, Medium=standard confirmations, Low=extra confirmations for safety. Control workflow autonomy based on user preference.",
+        "CONTEXT DOCUMENTATION: Maintain INVESTIGATION_CONTEXT.md throughout. Update after major milestones, failures, or user interventions to enable seamless handoffs between sessions.",
+        "GIT FALLBACK STRATEGY: If git unavailable, gracefully skip commits/branches, log changes manually in CONTEXT.md with timestamps, warn user, document modifications for manual control.",
+        "GIT ERROR HANDLING: Use run_terminal_cmd for git operations; if fails, output exact command for user manual execution. Never halt investigation due to git unavailability.",
+        "TOOL AVAILABILITY AWARENESS: Check debugging tool availability before investigation design. Have fallbacks for when primary tools unavailable (grep→file_search, etc).",
+        "SECURITY PROTOCOLS: Sanitize sensitive data in logs/reproduction steps. Be mindful of exposing credentials, PII, or system internals during evidence collection phases.",
+        "DYNAMIC RE-TRIAGE: Allow complexity upgrades during investigation if evidence reveals deeper issues. Safe downgrades only with explicit user confirmation after evidence review.",
+        "DEVIL'S ADVOCATE REVIEW: Actively challenge primary hypothesis with available evidence. Seek alternative explanations and rate alternative likelihood before final confidence assessment.",
+        "COLLABORATIVE HANDOFFS: Structure documentation for peer review and team coordination. Include methodology, reasoning, and complete evidence chain for knowledge transfer.",
+        "FAILURE BOUNDS: Track investigation progress. If >20 steps or >4 hours without breakthrough, pause for user guidance. Document dead ends to prevent redundant work in future sessions.",
+        "COGNITIVE BREAKS: After 10 investigation steps, pause and summarize progress to reset perspective.",
+        "RUBBER DUCK: Verbalize hypotheses in sub-prompts to externalize reasoning and catch logical gaps.",
+        "COLLABORATION READY: Document clearly for handoffs when stuck beyond iteration limits."
+    ],
+    "steps": [
+        {
+            "id": "phase-0-triage",
+            "title": "Phase 0: Initial Triage & Context Gathering",
+            "prompt": "**SYSTEMATIC INVESTIGATION BEGINS** - Your mission is to achieve near 100% certainty about this bug's root cause through systematic evidence gathering. NO FIXES will be proposed until Phase 6.\n\n**STEP 1: Bug Report Analysis**\nPlease provide the complete bug context:\n- **Bug Description**: What is the observed behavior vs expected behavior?\n- **Error Messages/Stack Traces**: Paste the complete error output\n- **Reproduction Steps**: How can this bug be consistently reproduced?\n- **Environment Details**: OS, language version, framework version, etc.\n- **Recent Changes**: Any recent commits, deployments, or configuration changes?\n\n**STEP 2: Project Type Classification**\nBased on the information provided, I will classify the project type and set debugging strategies:\n- **Languages/Frameworks**: Primary tech stack\n- **Build System**: Maven, Gradle, npm, etc.\n- **Testing Framework**: JUnit, Jest, pytest, etc.\n- **Logging System**: Available logging mechanisms\n- **Architecture**: Monolithic, microservices, distributed, serverless, etc.\n\n**STEP 3: Complexity Assessment**\nI will analyze the bug complexity using these criteria:\n- **Simple**: Single function/method, clear error path, minimal dependencies\n- **Standard**: Multiple components, moderate investigation required\n- **Complex**: Cross-system issues, race conditions, complex state management\n\n**OUTPUTS**: Set `projectType`, `bugComplexity`, `debuggingMechanism`, and `isDistributed` (true if architecture involves microservices/distributed systems) context variables.",
+            "agentRole": "You are a senior debugging specialist and bug triage expert with 15+ years of experience across multiple technology stacks. Your expertise lies in quickly classifying bugs, understanding project architectures, and determining appropriate investigation strategies. You excel at extracting critical information from bug reports and setting up systematic investigation approaches.",
+            "guidance": [
+                "CLASSIFICATION ACCURACY: Proper complexity assessment determines investigation depth - be thorough but decisive",
+                "CONTEXT CAPTURE: Gather complete environmental and situational context now to avoid gaps later",
+                "DEBUGGING STRATEGY: Choose debugging mechanisms appropriate for the project type and bug complexity",
+                "NO ASSUMPTIONS: If critical information is missing, explicitly request it before proceeding"
+            ]
+        },
+        {
+            "id": "phase-0a-assumption-check",
+            "title": "Phase 0a: Assumption Verification Checkpoint",
+            "prompt": "**ASSUMPTION CHECK** - Before proceeding, verify key assumptions to prevent bias.\n\n**VERIFY**:\n1. **Data State**: Confirm variable types and null handling\n2. **API/Library**: Check documentation for actual vs assumed behavior\n3. **Environment**: Verify bug exists in clean environment\n4. **Recent Changes**: Review last 5 commits for relevance\n\n**OUTPUT**: List verified assumptions with evidence sources.",
+            "agentRole": "You are a skeptical analyst who challenges every assumption. Question everything that hasn't been explicitly verified.",
+            "guidance": [
+                "Use analysis tools to verify, don't assume",
+                "Document each assumption with its verification method",
+                "Flag any unverifiable assumptions for tracking",
+                "CHECK API DOCS: Never assume function behavior from names - verify actual documentation",
+                "VERIFY DATA TYPES: Use debugger or logs to confirm actual runtime types and values",
+                "TEST ENVIRONMENT: Reproduce in minimal environment to rule out configuration issues"
+            ]
+        },
+        {
+            "id": "phase-0b-reproducibility-loop",
+            "type": "loop",
+            "title": "Phase 0b: Reproducibility Verification Loop",
+            "loop": {
+                "type": "for",
+                "count": 3,
+                "maxIterations": 3,
+                "iterationVar": "reproductionAttempt"
+            },
+            "body": [
+                {
+                    "id": "reproduce-bug",
+                    "title": "Reproduction Attempt {{reproductionAttempt}}/3",
+                    "prompt": "**REPRODUCTION ATTEMPT {{reproductionAttempt}}/3**\n\nExecute the provided reproduction steps:\n1. Follow exact steps from bug report\n2. Document outcome (Success/Failure)\n3. Note any variations in behavior\n4. Capture error messages/stack traces\n\n**Update context:**\n- Set `reproductionResults[{{reproductionAttempt - 1}}]` = true/false\n- If failed, document why\n- Track any intermittent patterns",
+                    "agentRole": "You are systematically verifying bug reproducibility to ensure solid investigation foundation.",
+                    "guidance": [
+                        "Execute exactly as specified",
+                        "Document any deviations",
+                        "Capture all error details"
+                    ],
+                    "requireConfirmation": false
+                }
+            ],
+            "requireConfirmation": false
+        },
+        {
+            "id": "phase-0c-reproducibility-assessment",
+            "title": "Phase 0c: Reproducibility Assessment",
+            "prompt": "**ASSESS REPRODUCIBILITY**\n\nBased on 3 reproduction attempts:\n- **Success Rate**: Calculate percentage\n- **Pattern Analysis**: Identify any intermittent patterns\n- **Minimal Reproduction**: Create simplified test case if needed\n\n**DECISION:**\n- If 100% reproducible: Proceed to Phase 1\n- If intermittent: Apply stress techniques and document patterns\n- If 0% reproducible: Request more information from user\n\n**Set `isReproducible` = true/false based on assessment**",
+            "agentRole": "You are assessing reproduction results to determine investigation viability.",
+            "guidance": [
+                "100% reproduction is ideal but not always required",
+                "Document intermittent patterns for investigation",
+                "Create minimal test case for complex scenarios"
+            ],
+            "validationCriteria": [
+                {
+                    "type": "contains",
+                    "value": "reproducib",
+                    "message": "Must make reproducibility determination"
+                }
+            ],
+            "hasValidation": true,
+            "runCondition": {
+                "var": "reproductionAttempt",
+                "equals": 3
+            }
+        },
+        {
+            "id": "phase-1-streamlined-analysis",
+            "runCondition": {
+                "var": "bugComplexity",
+                "equals": "simple"
+            },
+            "title": "Phase 1: Streamlined Analysis (Simple Bugs)",
+            "prompt": "**STREAMLINED CODEBASE INVESTIGATION** - For simple bugs, I will perform focused analysis of the core issue.\n\n**STEP 1: Direct Component Analysis**\nI will examine the specific component involved:\n- **Primary Function/Method**: Direct analysis of the failing code\n- **Input/Output Analysis**: What data enters and exits the component\n- **Logic Flow**: Step-by-step execution path\n- **Error Point**: Exact location where failure occurs\n\n**STEP 2: Immediate Context Review**\n- **Recent Changes**: Git commits affecting this specific component\n- **Related Tests**: Existing test coverage for this functionality\n- **Dependencies**: Direct dependencies that could affect this component\n\n**STEP 3: Quick Hypothesis Formation**\nI will generate 1-3 focused hypotheses based on:\n- **Obvious Error Patterns**: Common failure modes for this type of component\n- **Change Impact**: How recent modifications could cause this issue\n- **Input Validation**: Whether invalid inputs are causing the failure\n\n**OUTPUTS**: Focused understanding of the simple bug with 1-3 targeted hypotheses ready for validation.",
+            "agentRole": "You are an experienced debugging specialist who excels at quickly identifying and resolving straightforward technical issues. Your strength lies in pattern recognition and efficient root cause analysis for simple bugs. You focus on the most likely causes while avoiding over-analysis.",
+            "guidance": [
+                "FOCUSED ANALYSIS: Concentrate on the specific failing component, avoid deep architectural analysis",
+                "PATTERN RECOGNITION: Use experience to identify common failure modes quickly",
+                "EFFICIENT HYPOTHESIS: Generate 1-3 focused hypotheses, not exhaustive possibilities",
+                "DIRECT APPROACH: Skip complex dependency analysis unless directly relevant"
+            ]
+        },
+        {
+            "id": "phase-1-comprehensive-analysis",
+            "runCondition": {
+                "or": [
+                    {
+                        "var": "bugComplexity",
+                        "equals": "standard"
+                    },
+                    {
+                        "var": "bugComplexity",
+                        "equals": "complex"
+                    }
+                ]
+            },
+            "title": "Phase 1: Deep Codebase Analysis (Standard/Complex Bugs)",
+            "prompt": "**SYSTEMATIC CODEBASE INVESTIGATION** - I will now perform comprehensive analysis of the relevant codebase components.\n\n**STEP 1: Affected Component Identification**\nBased on the bug report, I will identify and analyze:\n- **Primary Components**: Classes, functions, modules directly involved\n- **Dependency Chain**: Related components that could influence the bug\n- **Data Flow**: How data moves through the affected systems\n- **Error Propagation Paths**: Where and how errors can originate and propagate\n\n**STEP 2: Code Structure Analysis**\nFor each relevant component, I will examine:\n- **Implementation Logic**: Step-by-step code execution flow\n- **State Management**: How state is created, modified, and shared\n- **Error Handling**: Existing error handling mechanisms\n- **External Dependencies**: Third-party libraries, APIs, database interactions\n- **Concurrency Patterns**: Threading, async operations, shared resources\n\n**STEP 3: Historical Context Review**\nI will analyze:\n- **Recent Changes**: Git history around the affected components\n- **Test Coverage**: Existing tests and their coverage of the bug area\n- **Known Issues**: TODO comments, FIXME notes, or similar patterns\n\n**STEP 4: Recursive Dependency Dive**\nFor key components, analyze dependencies and internals recursively to uncover hidden issues.\n\n**OUTPUTS**: Comprehensive understanding of the codebase architecture and potential failure points.",
+            "agentRole": "You are a principal software architect and code analysis expert specializing in systematic codebase investigation. Your strength lies in quickly understanding complex system architectures, identifying failure points, and tracing execution flows. You excel at connecting code patterns to potential runtime behaviors.",
+            "guidance": [
+                "SYSTEMATIC COVERAGE: Analyze all relevant components, not just the obvious ones",
+                "EXECUTION FLOW FOCUS: Trace the actual code execution path that leads to the bug",
+                "STATE ANALYSIS: Pay special attention to state management and mutation patterns",
+                "DEPENDENCY MAPPING: Understand how external dependencies could contribute to the issue"
+            ]
+        },
+        {
+            "id": "phase-1a-binary-search",
+            "title": "Phase 1a: Binary Search Isolation",
+            "runCondition": {
+                "or": [
+                    {"var": "bugType", "equals": "regression"},
+                    {"var": "searchSpace", "equals": "large"}
+                ]
+            },
+            "prompt": "**BINARY SEARCH** - Apply divide-and-conquer:\n\n1. Identify GOOD state (working) and BAD state (broken)\n2. Find midpoint in history/code/data\n3. Test midpoint state\n4. Narrow to relevant half\n5. Document reduced search space\n\n**OUTPUT**: Narrowed location with evidence.",
+            "agentRole": "You are a systematic investigator using algorithmic search to efficiently isolate issues.",
+            "guidance": [
+                "VERSION CONTROL: Use 'git bisect' or equivalent for commit history searches",
+                "DATA PIPELINE: Test data at pipeline midpoints to isolate transformation issues",
+                "TIME WINDOWS: For time-based issues, binary search through timestamps",
+                "DOCUMENT BOUNDARIES: Clearly record each tested boundary and result",
+                "EFFICIENCY: Each test should eliminate ~50% of remaining search space"
+            ]
+        },
+        {
+            "id": "phase-1b-test-reduction",
+            "title": "Phase 1b: Test Case Minimization",
+            "runCondition": {
+                "var": "bugSource",
+                "equals": "failing_test"
+            },
+            "prompt": "**TEST REDUCTION** - Simplify failing test:\n\n1. Inline called methods into test\n2. Add earlier assertion to fail sooner\n3. Remove code after new failure point\n4. Repeat until minimal\n\n**OUTPUT**: Minimal failing test case.",
+            "agentRole": "You are a surgical debugger who strips away layers to reveal core issues.",
+            "guidance": [
+                "PRESERVE FAILURE: Each reduction must maintain the original failure mode",
+                "INLINE AGGRESSIVELY: Replace method calls with their actual implementation",
+                "FAIL EARLY: Move assertions up to find earliest deviation from expected state",
+                "REMOVE RUTHLESSLY: Delete all code that doesn't contribute to the failure",
+                "CLARITY GOAL: Final test should make the bug obvious to any reader"
+            ]
+        },
+        {
+            "id": "phase-2a-hypothesis-development",
+            "title": "Phase 2a: Hypothesis Development & Prioritization",
+            "prompt": "**HYPOTHESIS GENERATION** - Based on codebase analysis, formulate testable hypotheses about the bug's root cause.\n\n**STEP 1: Evidence-Based Hypothesis Development**\nCreate maximum 5 prioritized hypotheses. Each includes:\n- **Root Cause Theory**: Specific technical explanation\n- **Supporting Evidence**: Code patterns/logic flows supporting this theory\n- **Failure Mechanism**: Exact sequence leading to observed bug\n- **Testability Score**: Quantified assessment (1-10) of validation ease\n- **Evidence Strength Score**: Quantified assessment (1-10) based on code findings\n\n**STEP 2: Hypothesis Prioritization Matrix**\nRank hypotheses using weighted scoring:\n- **Evidence Strength** (40%): Code analysis support for theory\n- **Testability** (35%): Validation ease with debugging instruments\n- **Impact Scope** (25%): How well this explains all symptoms\n\n**CRITICAL RULE**: All hypotheses must be based on concrete evidence from code analysis.\n\n**OUTPUTS**: Maximum 5 hypotheses with quantified scoring, ranked by priority.",
+            "agentRole": "You are a senior software detective and root cause analysis expert with deep expertise in systematic hypothesis formation. Your strength lies in connecting code evidence to potential failure mechanisms and creating testable theories. You excel at logical reasoning and evidence-based deduction. You must maintain rigorous quantitative standards and reject any hypothesis not grounded in concrete code evidence.",
+            "guidance": [
+                "EVIDENCE-BASED ONLY: Every hypothesis must be grounded in concrete code analysis findings with quantified evidence scores",
+                "HYPOTHESIS LIMITS: Generate maximum 5 hypotheses to prevent analysis paralysis",
+                "QUANTIFIED SCORING: Use 1-10 scales for evidence strength and testability with clear criteria"
+            ],
+            "validationCriteria": [
+                {
+                    "type": "contains",
+                    "value": "Evidence Strength Score",
+                    "message": "Must include quantified evidence strength scoring (1-10) for each hypothesis"
+                },
+                {
+                    "type": "contains",
+                    "value": "Testability Score",
+                    "message": "Must include quantified testability scoring (1-10) for each hypothesis"
+                }
+            ],
+            "hasValidation": true
+        },
+        {
+            "id": "phase-2b-hypothesis-validation-strategy",
+            "title": "Phase 2b: Hypothesis Validation Strategy & Documentation",
+            "prompt": "**HYPOTHESIS VALIDATION PLANNING** - For the top 3 hypotheses, create validation strategies and documentation.\n\n**STEP 1: Hypothesis Validation Strategy**\nFor top 3 hypotheses, define:\n- **Required Evidence**: Specific evidence to confirm/refute hypothesis\n- **Debugging Approach**: Instrumentation/tests providing evidence\n- **Success Criteria**: Results proving hypothesis correct\n- **Confidence Threshold**: Minimum evidence quality needed\n\n**STEP 2: Hypothesis Documentation**\nCreate structured registry:\n- **Hypothesis ID**: H1, H2, H3 for tracking\n- **Status**: Active, Refuted, Confirmed\n- **Evidence Log**: Supporting and contradicting evidence\n- **Validation Plan**: Specific testing approach\n\n**STEP 3: Coverage Check**\nEnsure hypotheses cover diverse categories (logic, state, dependencies) with deep analysis.\n\n**OUTPUTS**: Top 3 hypotheses selected for validation with structured documentation and validation plans.",
+            "agentRole": "You are a systematic testing strategist and documentation expert. Your strength lies in creating clear validation plans and maintaining rigorous documentation standards for hypothesis tracking and evidence collection.",
+            "guidance": [
+                "STRUCTURED DOCUMENTATION: Create formal hypothesis registry with tracking IDs and status",
+                "VALIDATION RIGOR: Only proceed with top 3 hypotheses that meet minimum evidence thresholds",
+                "COMPREHENSIVE PLANNING: Each hypothesis must have clear validation approach and success criteria"
+            ],
+            "validationCriteria": [
+                {
+                    "type": "contains",
+                    "value": "Hypothesis ID",
+                    "message": "Must assign tracking IDs (H1, H2, H3) to each hypothesis"
+                },
+                {
+                    "type": "regex",
+                    "pattern": "H[1-3]",
+                    "message": "Must use proper hypothesis ID format (H1, H2, H3)"
+                }
+            ],
+            "hasValidation": true
+        },
+        {
+            "id": "phase-2c-prepare-validation",
+            "title": "Phase 2c: Prepare Hypothesis Validation",
+            "prompt": "**PREPARE VALIDATION ARRAY** - Extract the top 3 hypotheses for systematic validation.\n\n**Create `hypothesesToValidate` array with:**\n```json\n[\n  {\n    \"id\": \"H1\",\n    \"description\": \"[Hypothesis description]\",\n    \"evidenceStrength\": [score],\n    \"testability\": [score],\n    \"validationPlan\": \"[Specific testing approach]\"\n  },\n  // ... H2, H3\n]\n```\n\n**Set context variables:**\n- `hypothesesToValidate`: Array of top 3 hypotheses\n- `currentConfidence`: 0 (will be updated during validation)\n- `validationIterations`: 0 (tracks validation cycles)",
+            "agentRole": "You are preparing the systematic validation process by structuring hypotheses for iteration.",
+            "guidance": [
+                "Extract only the top 3 hypotheses from Phase 2b",
+                "Ensure each has complete validation information",
+                "Initialize tracking variables for the validation loop"
+            ],
+            "requireConfirmation": false
+        },
+        {
+            "id": "phase-3-4-5-validation-loop",
+            "type": "loop",
+            "title": "Hypothesis Validation Loop (Phases 3-4-5)",
+            "loop": {
+                "type": "forEach",
+                "items": "hypothesesToValidate",
+                "itemVar": "currentHypothesis",
+                "indexVar": "hypothesisIndex",
+                "maxIterations": 5
+            },
+            "body": [
+                {
+                    "id": "loop-phase-3-instrumentation",
+                    "title": "Phase 3: Debug Instrumentation for {{currentHypothesis.id}}",
+                    "prompt": "**DEBUGGING INSTRUMENTATION for {{currentHypothesis.id}}**\n\n**Hypothesis**: {{currentHypothesis.description}}\n**Validation Plan**: {{currentHypothesis.validationPlan}}\n\n**IMPLEMENT INSTRUMENTATION:**\n1. **Strategy**: Choose based on hypothesis needs (logging, debug prints, test mods)\n2. **Coverage**: Instrument all paths related to {{currentHypothesis.id}}\n3. **Evidence Points**: Focus on gathering evidence that will confirm/refute this specific hypothesis\n\n**LOG OPTIMIZATION:**\n- Use '{{currentHypothesis.id}}_DEBUG:' prefix for all logs\n- Implement deduplication for high-frequency events\n- Group related operations within 50-100ms windows\n\n**OUTPUT**: Instrumented code ready to validate {{currentHypothesis.id}}",
+                    "agentRole": "You are instrumenting code specifically to validate hypothesis {{currentHypothesis.id}}. Focus on targeted evidence collection.",
+                    "guidance": [
+                        "This is hypothesis {{hypothesisIndex + 1}} of {{hypothesesToValidate.length}}",
+                        "Tailor instrumentation to the specific hypothesis",
+                        "Ensure non-intrusive implementation"
+                    ],
+                    "requireConfirmation": false
+                },
+                {
+                    "id": "loop-phase-4-evidence",
+                    "title": "Phase 4: Evidence Collection for {{currentHypothesis.id}}",
+                    "prompt": "**EVIDENCE COLLECTION for {{currentHypothesis.id}}**\n\n**Execute instrumented code and collect evidence:**\n1. Run the instrumented test/reproduction\n2. Collect all {{currentHypothesis.id}}_DEBUG logs\n3. Analyze results against validation criteria\n4. Document evidence quality and relevance\n\n**EVIDENCE ASSESSMENT:**\n- Does evidence support {{currentHypothesis.id}}? (Yes/No/Partial)\n- Evidence quality score (1-10)\n- Contradicting evidence found?\n- Additional evidence needed?\n\n**If log volume >500 lines, create sub-analysis prompt.**\n\n**OUTPUT**: Evidence assessment for {{currentHypothesis.id}} with quality scoring",
+                    "agentRole": "You are collecting and analyzing evidence specifically for hypothesis {{currentHypothesis.id}}.",
+                    "guidance": [
+                        "Focus on evidence directly related to this hypothesis",
+                        "Be objective in assessment - negative evidence is valuable",
+                        "Track evidence quality quantitatively"
+                    ],
+                    "requireConfirmation": false
+                },
+                {
+                    "id": "loop-phase-5-synthesis",
+                    "title": "Phase 5: Evidence Synthesis for {{currentHypothesis.id}}",
+                    "prompt": "**EVIDENCE SYNTHESIS for {{currentHypothesis.id}}**\n\n**Synthesize findings:**\n1. **Evidence Summary**: What did we learn about {{currentHypothesis.id}}?\n2. **Confidence Update**: Based on evidence, rate confidence this is the root cause (0-10)\n3. **Status Update**: Mark hypothesis as Confirmed/Refuted/Needs-More-Evidence\n\n**If {{currentHypothesis.id}} is confirmed with high confidence (>8.0):**\n- Set `rootCauseFound` = true\n- Set `rootCauseHypothesis` = {{currentHypothesis.id}}\n- Update `currentConfidence` with confidence score\n\n**If all hypotheses validated but confidence <9.0:**\n- Consider additional investigation needs\n- Document what evidence is still missing",
+                    "agentRole": "You are synthesizing evidence to determine if {{currentHypothesis.id}} is the root cause.",
+                    "guidance": [
+                        "Update hypothesis status based on evidence",
+                        "Track overall investigation confidence",
+                        "Be ready to exit loop if root cause found with high confidence"
+                    ],
+                    "requireConfirmation": false
+                }
+            ],
+            "runCondition": {
+                "and": [
+                    { "var": "rootCauseFound", "not_equals": true },
+                    { "var": "validationIterations", "lt": 3 }
+                ]
+            },
+            "requireConfirmation": false
+        },
+        {
+            "id": "phase-3a-observability-setup",
+            "title": "Phase 3a: Distributed System Observability",
+            "runCondition": {
+                "var": "isDistributed",
+                "equals": true
+            },
+            "prompt": "**OBSERVABILITY** - Set up three-pillar strategy:\n\n**METRICS**: Identify key indicators (latency, errors)\n**TRACES**: Enable request path tracking\n**LOGS**: Ensure correlation IDs present\n\n**OUTPUT**: Observability checklist completed.",
+            "agentRole": "You are a distributed systems expert who thinks in terms of emergent behaviors and system-wide patterns.",
+            "guidance": [
+                "METRICS SELECTION: Focus on RED metrics (Rate, Errors, Duration) for each service",
+                "TRACE COVERAGE: Ensure spans cover all service boundaries and key operations",
+                "CORRELATION IDS: Verify IDs propagate through entire request lifecycle",
+                "AGGREGATION READY: Set up centralized collection for cross-service analysis",
+                "BASELINE ESTABLISHMENT: Capture normal behavior metrics for comparison"
+            ]
+        },
+        {
+            "id": "phase-4a-distributed-evidence",
+            "title": "Phase 4a: Multi-Service Evidence Collection",
+            "runCondition": {
+                "var": "isDistributed",
+                "equals": true
+            },
+            "prompt": "**DISTRIBUTED ANALYSIS**:\n\n1. Check METRICS for anomalies\n2. Follow TRACES for request path\n3. Correlate LOGS across services\n4. Identify cascade points\n\n**OUTPUT**: Service interaction map with failure points.",
+            "agentRole": "You are a systems detective who can trace failures across service boundaries.",
+            "guidance": [
+                "ANOMALY DETECTION: Look for deviations in latency, error rates, or traffic patterns",
+                "TRACE ANALYSIS: Follow request ID through all services to find failure point",
+                "LOG CORRELATION: Use timestamp windows and correlation IDs to link events",
+                "CASCADE IDENTIFICATION: Look for timeout chains or error propagation patterns",
+                "VISUAL MAPPING: Create service dependency diagram with failure annotations"
+            ]
+        },
+        {
+            "id": "phase-4b-cognitive-reset",
+            "title": "Phase 4b: Cognitive Reset & Progress Review",
+            "runCondition": {
+                "var": "validationIterations",
+                "gte": 2
+            },
+            "prompt": "**COGNITIVE RESET** - Step back and review:\n\n1. Summarize findings so far\n2. List eliminated possibilities\n3. Identify investigation blind spots\n4. Reformulate approach if needed\n\n**DECIDE**: Continue current path or pivot strategy?",
+            "agentRole": "You are a strategic advisor who helps maintain perspective during complex investigations.",
+            "guidance": [
+                "PROGRESS SUMMARY: Write concise bullet points of key findings and eliminations",
+                "BLIND SPOT CHECK: What areas haven't been investigated? What assumptions remain?",
+                "PATTERN RECOGNITION: Look for investigation loops or repeated dead ends",
+                "STRATEGY EVALUATION: Is current approach yielding diminishing returns?",
+                "PIVOT CRITERIA: Consider new approach if last 3 iterations provided no new insights"
+            ]
+        },
+        {
+            "id": "phase-5a-final-confidence",
+            "title": "Phase 5a: Final Confidence Assessment",
+            "prompt": "**FINAL CONFIDENCE ASSESSMENT** - Evaluate the investigation results.\n\n**If root cause found (rootCauseFound = true):**\n- Review all evidence for {{rootCauseHypothesis}}\n- Perform adversarial challenge\n- Calculate final confidence score\n\n**If no high-confidence root cause:**\n- Document what was learned\n- Identify remaining unknowns\n- Recommend next investigation steps\n\n**CONFIDENCE CALCULATION:**\n- Evidence Quality (1-10)\n- Explanation Completeness (1-10)\n- Alternative Likelihood (1-10, inverted)\n- Final = (Quality × 0.4) + (Completeness × 0.4) + (Alternative × 0.2)\n\n**OUTPUT**: Final confidence assessment with recommendations",
+            "agentRole": "You are making the final determination about the root cause with rigorous confidence assessment.",
+            "guidance": [
+                "Be honest about confidence levels",
+                "Document all remaining uncertainties",
+                "Provide clear next steps if confidence is low"
+            ],
+            "validationCriteria": [
+                {
+                    "type": "regex",
+                    "pattern": "Final.*=.*[0-9\\.]+",
+                    "message": "Must calculate final confidence score"
+                }
+            ],
+            "hasValidation": true
+        },
+        {
+            "id": "phase-2c-hypothesis-assumptions",
+            "title": "Phase 2c: Hypothesis Assumption Audit",
+            "prompt": "**AUDIT** each hypothesis for hidden assumptions:\n\n**FOR EACH HYPOTHESIS**:\n- List implicit assumptions\n- Rate assumption confidence (1-10)\n- Identify verification approach\n\n**REJECT** hypotheses built on unverified assumptions.",
+            "agentRole": "You are a rigorous scientist who rejects any hypothesis not grounded in verified facts.",
+            "guidance": [
+                "EXPLICIT LISTING: Write out every assumption, no matter how obvious it seems",
+                "CONFIDENCE SCORING: Rate 1-10 based on evidence quality, not intuition",
+                "VERIFICATION PLAN: For each assumption, specify how it can be tested",
+                "REJECTION CRITERIA: Any assumption with confidence <7 requires verification",
+                "DOCUMENT RATIONALE: Explain why each assumption is accepted or needs testing"
+            ],
+            "validationCriteria": [
+                {
+                    "type": "contains",
+                    "value": "Assumption confidence",
+                    "message": "Must rate assumption confidence for each hypothesis"
+                }
+            ],
+            "hasValidation": true
+        },
+        {
+            "id": "phase-6-diagnostic-writeup",
+            "title": "Phase 6: Comprehensive Diagnostic Writeup",
+            "prompt": "**FINAL DIAGNOSTIC DOCUMENTATION** - I will create comprehensive writeup enabling effective bug fixing and knowledge transfer.\n\n**STEP 1: Executive Summary**\n- **Bug Summary**: Concise description of issue and impact\n- **Root Cause**: Clear, non-technical explanation of what is happening\n- **Confidence Level**: Final confidence assessment with calculation methodology\n- **Scope**: What systems, users, or scenarios are affected\n\n**STEP 2: Technical Deep Dive**\n- **Root Cause Analysis**: Detailed technical explanation of failure mechanism\n- **Code Component Analysis**: Specific files, functions, and lines with exact locations\n- **Execution Flow**: Step-by-step sequence of events leading to bug\n- **State Analysis**: How system state contributes to failure\n\n**STEP 3: Investigation Methodology**\n- **Investigation Timeline**: Chronological summary with phase time investments\n- **Hypothesis Evolution**: Complete record of hypotheses (H1-H5) with status changes\n- **Evidence Assessment**: Rating and reliability of evidence sources with key citations\n\n**STEP 4: Knowledge Transfer & Action Plan**\n- **Skill Requirements**: Technical expertise needed for understanding and fixing\n- **Prevention & Review**: Specific measures and code review checklist items\n- **Action Items**: Immediate mitigation steps and permanent fix areas with timelines\n- **Testing Strategy**: Comprehensive verification approach for fixes\n\n**DELIVERABLE**: Enterprise-grade diagnostic report enabling confident bug fixing, knowledge transfer, and organizational learning.",
+            "agentRole": "You are a senior technical writer and diagnostic documentation specialist with expertise in creating comprehensive, actionable bug reports for enterprise environments. Your strength lies in translating complex technical investigations into clear, structured documentation that enables effective problem resolution, knowledge transfer, and organizational learning. You excel at creating reports that serve immediate fixing needs, long-term system improvement, and team collaboration.",
+            "guidance": [
+                "ENTERPRISE FOCUS: Write for multiple stakeholders including developers, managers, and future team members",
+                "KNOWLEDGE TRANSFER: Include methodology and reasoning, not just conclusions",
+                "COLLABORATIVE DESIGN: Structure content for peer review and team coordination",
+                "COMPREHENSIVE COVERAGE: Include all information needed for resolution and prevention",
+                "ACTIONABLE DOCUMENTATION: Provide specific, concrete next steps with clear ownership"
+            ]
+        }
+    ]
+}