pdd-cli 0.0.90__py3-none-any.whl → 0.0.121__py3-none-any.whl

pdd/postprocess.py

@@ -1,133 +1,158 @@
-from typing import Tuple
-from rich import print
-from pydantic import BaseModel, Field
+from __future__ import annotations
+
+import re
+from typing import Tuple, Optional
+
+from rich.console import Console
+from pydantic import BaseModel, Field, ValidationError
+
+from . import DEFAULT_STRENGTH, DEFAULT_TIME
 from .load_prompt_template import load_prompt_template
 from .llm_invoke import llm_invoke
-from . import DEFAULT_TIME, DEFAULT_STRENGTH
+
+
+console = Console()
+
 
 class ExtractedCode(BaseModel):
-    """Pydantic model for the extracted code."""
-    extracted_code: str = Field(description="The extracted code from the LLM output")
+    focus: str = Field("", description="Focus of the code")
+    explanation: str = Field("", description="Explanation of the code")
+    extracted_code: str = Field(..., description="Extracted code")
+
+
+def postprocess_0(llm_output: str, language: str) -> str:
+    """Simple extraction of code blocks."""
+    if language == "prompt":
+        # Strip <prompt> tags
+        llm_output = re.sub(r"<prompt>\s*(.*?)\s*</prompt>", r"\1", llm_output, flags=re.DOTALL)
+        llm_output = llm_output.strip()
+
+        # Also strip triple backticks if present
+        lines = llm_output.splitlines()
+        if lines and lines[0].startswith("```"):
+            # Remove first line with opening backticks
+            lines = lines[1:]
+            # If there's a last line with closing backticks, remove it
+            if lines and lines[-1].startswith("```"):
+                lines = lines[:-1]
+        llm_output = "\n".join(lines)
+
+        return llm_output.strip()
+
+    # First try to find complete code blocks with closing backticks
+    code_blocks = re.findall(r"```(?:[a-zA-Z]+)?\n(.*?)\n```", llm_output, re.DOTALL)
+    if code_blocks:
+        return "\n".join(block.strip() for block in code_blocks)
+
+    # If no complete blocks found, try to find incomplete blocks (opening backticks without closing)
+    # But ensure there's actual content after the opening backticks
+    incomplete_match = re.search(r"```(?:[a-zA-Z]+)?\n(.+?)(?:\n```)?$", llm_output, re.DOTALL)
+    if incomplete_match:
+        content = incomplete_match.group(1).strip()
+        # Don't return if content is just closing backticks
+        if content and content != "```":
+            return content
+
+    return ""
 
-def postprocess_0(text: str) -> str:
-    """
-    Simple code extraction for strength = 0.
-    Extracts code between triple backticks.
-    """
-    lines = text.split('\n')
-    code_lines = []
-    in_code_block = False
-    
-    for line in lines:
-        if '```' in line: # MODIFIED: Was line.startswith('```')
-            if not in_code_block:
-                # Skip the language identifier line / content on opening delimiter line
-                in_code_block = True
-                continue
-            else:
-                # Content on closing delimiter line is skipped
-                in_code_block = False
-                continue
-        if in_code_block:
-            code_lines.append(line)
-    
-    return '\n'.join(code_lines)
 
 def postprocess(
     llm_output: str,
     language: str,
     strength: float = DEFAULT_STRENGTH,
-    temperature: float = 0,
+    temperature: float = 0.0,
     time: float = DEFAULT_TIME,
-    verbose: bool = False
+    verbose: bool = False,
 ) -> Tuple[str, float, str]:
     """
-    Extract code from LLM output string.
-    
+    Extracts code from a string output of an LLM.
+
     Args:
-        llm_output (str): The string output from the LLM containing code sections
-        language (str): The programming language of the code to extract
-        strength (float): The strength of the LLM model to use (0-1)
-        temperature (float): The temperature parameter for the LLM (0-1)
-        time (float): The thinking effort for the LLM model (0-1)
-        verbose (bool): Whether to print detailed processing information
-    
+        llm_output: A string containing a mix of text and code sections.
+        language: A string specifying the programming language of the code to be extracted.
+        strength: A float between 0 and 1 that represents the strength of the LLM model to use.
+        temperature: A float between 0 and 1 that represents the temperature parameter for the LLM model.
+        time: A float between 0 and 1 that controls the thinking effort for the LLM model.
+        verbose: A boolean that indicates whether to print detailed processing information.
+
     Returns:
-        Tuple[str, float, str]: (extracted_code, total_cost, model_name)
+        A tuple containing the extracted code string, total cost float and model name string.
     """
-    try:
-        # Input validation
-        if not llm_output or not isinstance(llm_output, str):
-            raise ValueError("llm_output must be a non-empty string")
-        if not language or not isinstance(language, str):
-            raise ValueError("language must be a non-empty string")
-        if not 0 <= strength <= 1:
-            raise ValueError("strength must be between 0 and 1")
-        if not 0 <= temperature <= 1:
-            raise ValueError("temperature must be between 0 and 1")
-
-        # Step 1: If strength is 0, use simple extraction
-        if strength == 0:
-            if verbose:
-                print("[blue]Using simple code extraction (strength = 0)[/blue]")
-            return (postprocess_0(llm_output), 0.0, "simple_extraction")
-
-        # Step 2: Load the prompt template
-        prompt_template = load_prompt_template("extract_code_LLM")
-        if not prompt_template:
-            raise ValueError("Failed to load prompt template")
+    if not isinstance(llm_output, str) or not llm_output:
+        raise ValueError("llm_output must be a non-empty string")
+    if not isinstance(language, str) or not language:
+        raise ValueError("language must be a non-empty string")
+    if not isinstance(strength, (int, float)):
+        raise TypeError("strength must be a number")
+    if not 0 <= strength <= 1:
+        raise ValueError("strength must be between 0 and 1")
+    if not isinstance(temperature, (int, float)):
+        raise TypeError("temperature must be a number")
+    if not 0 <= temperature <= 1:
+        raise ValueError("temperature must be between 0 and 1")
 
+    if language == "prompt":
+        extracted_code = postprocess_0(llm_output, language)
+        return extracted_code, 0.0, "simple_extraction"
+    
+    if strength == 0:
+        extracted_code = postprocess_0(llm_output, language)
         if verbose:
-            print("[blue]Loaded prompt template for code extraction[/blue]")
+            console.print("[blue]Using simple code extraction (strength = 0)[/blue]")
+        return extracted_code, 0.0, "simple_extraction"
 
-        # Step 3: Process using llm_invoke
-        input_json = {
-            "llm_output": llm_output,
-            "language": language
-        }
+    prompt_name = "extract_code_LLM"
+    prompt = load_prompt_template(prompt_name)
 
-        response = llm_invoke(
-            prompt=prompt_template,
+    if not prompt:
+        error_msg = "Failed to load prompt template"
+        console.print(f"[red]Error:[/red] {error_msg}")
+        raise ValueError(error_msg)
+
+    input_json = {"llm_output": llm_output, "language": language}
+
+    if verbose:
+        console.print("[blue]Loaded prompt template for code extraction[/blue]")
+
+    try:
+        result = llm_invoke(
+            prompt=prompt,
             input_json=input_json,
             strength=strength,
             temperature=temperature,
             time=time,
+            output_pydantic=ExtractedCode,
             verbose=verbose,
-            output_pydantic=ExtractedCode
         )
 
-        if not response or 'result' not in response:
-            raise ValueError("Failed to get valid response from LLM")
+        if not result or "result" not in result:
+            error_msg = "Failed to get valid response from LLM"
+            console.print(f"[red]Error during LLM invocation:[/red] {error_msg}")
+            raise ValueError(error_msg)
 
-        result_obj = response['result']
-        if not isinstance(result_obj, ExtractedCode):
-            # If we got a string (likely an error message from llm_invoke), fallback to simple extraction
-            if verbose:
-                print(f"[yellow]Structured extraction failed ({result_obj}). Falling back to simple extraction.[/yellow]")
-            return (postprocess_0(llm_output), response.get('cost', 0.0), response.get('model_name', 'fallback'))
+        extracted_code = result["result"].extracted_code
 
-        extracted_code_obj: ExtractedCode = result_obj
-        code_text = extracted_code_obj.extracted_code
-
-        # Step 3c: Remove triple backticks and language identifier if present
-        lines = code_text.split('\n')
-        if lines and lines[0].startswith('```'):
+        # Clean up triple backticks
+        lines = extracted_code.splitlines()
+        if lines and lines[0].startswith("```"):
+            # Remove first line with opening backticks
             lines = lines[1:]
-        if lines and lines[-1].startswith('```'): # Check if lines is not empty again after potentially removing first line
-            lines = lines[:-1]
-        
-        final_code = '\n'.join(lines)
+            # If there's a last line with closing backticks, remove it
+            if lines and lines[-1].startswith("```"):
+                lines = lines[:-1]
+        extracted_code = "\n".join(lines)
+
+        total_cost = result["cost"]
+        model_name = result["model_name"]
 
         if verbose:
-            print("[green]Successfully extracted code[/green]")
+            console.print("[green]Successfully extracted code[/green]")
 
-        # Step 4: Return the results
-        return (
-            final_code,
-            response['cost'],
-            response['model_name']
-        )
+        return extracted_code, total_cost, model_name
 
+    except KeyError as e:
+        console.print(f"[red]Error in postprocess: {e}[/red]")
+        raise ValueError(f"Failed to get valid response from LLM: missing key {e}")
     except Exception as e:
-        print(f"[red]Error in postprocess: {str(e)}[/red]")
+        console.print(f"[red]Error in postprocess: {e}[/red]")
         raise

pdd/preprocess.py

@@ -4,10 +4,12 @@ import base64
 import subprocess
 from typing import List, Optional, Tuple
 import traceback
+from pathlib import Path
 from rich.console import Console
 from rich.panel import Panel
 from rich.markup import escape
 from rich.traceback import install
+from pdd.path_resolution import get_default_resolver
 
 install()
 console = Console()
@@ -37,24 +39,51 @@ def _write_debug_report() -> None:
         console.print("[dim]Debug mode enabled but PDD_PREPROCESS_DEBUG_FILE not set (output shown in console only)[/dim]")
 
 def _extract_fence_spans(text: str) -> List[Tuple[int, int]]:
-    """Return list of (start, end) spans for fenced code blocks ```...```.
+    """Return list of (start, end) spans for fenced code blocks (``` or ~~~).
 
     The spans are [start, end) indices in the original text.
     """
     spans: List[Tuple[int, int]] = []
     try:
-        for m in re.finditer(r"```[\w\s]*\n[\s\S]*?```", text):
+        fence_re = re.compile(
+            r"(?m)^[ \t]*([`~]{3,})[^\n]*\n[\s\S]*?\n[ \t]*\1[ \t]*(?:\n|$)"
+        )
+        for m in fence_re.finditer(text):
             spans.append((m.start(), m.end()))
     except Exception:
         pass
     return spans
 
+
+def _extract_inline_code_spans(text: str) -> List[Tuple[int, int]]:
+    """Return list of (start, end) spans for inline code (backticks)."""
+    spans: List[Tuple[int, int]] = []
+    try:
+        for m in re.finditer(r"(?<!`)(`+)([^\n]*?)\1", text):
+            spans.append((m.start(), m.end()))
+    except Exception:
+        pass
+    return spans
+
+
+def _extract_code_spans(text: str) -> List[Tuple[int, int]]:
+    spans = _extract_fence_spans(text)
+    spans.extend(_extract_inline_code_spans(text))
+    return sorted(spans, key=lambda s: s[0])
+
 def _is_inside_any_span(idx: int, spans: List[Tuple[int, int]]) -> bool:
     for s, e in spans:
         if s <= idx < e:
             return True
     return False
 
+
+def _intersects_any_span(start: int, end: int, spans: List[Tuple[int, int]]) -> bool:
+    for s, e in spans:
+        if start < e and end > s:
+            return True
+    return False
+
 def _scan_risky_placeholders(text: str) -> Tuple[List[Tuple[int, str]], List[Tuple[int, str]]]:
     """Scan for risky placeholders outside code fences.
 
@@ -119,8 +148,11 @@ def preprocess(prompt: str, recursive: bool = False, double_curly_brackets: bool
         return prompt
 
 def get_file_path(file_name: str) -> str:
-    base_path = './'
-    return os.path.join(base_path, file_name)
+    resolver = get_default_resolver()
+    resolved = resolver.resolve_include(file_name)
+    if not Path(file_name).is_absolute() and resolved == resolver.cwd / file_name:
+        return os.path.join("./", file_name)
+    return str(resolved)
 
 def process_backtick_includes(text: str, recursive: bool) -> str:
     # More specific pattern that doesn't match nested > characters
@@ -229,7 +261,12 @@ def process_include_tags(text: str, recursive: bool) -> str:
     current_text = text
     while prev_text != current_text:
         prev_text = current_text
-        current_text = re.sub(pattern, replace_include, current_text, flags=re.DOTALL)
+        code_spans = _extract_code_spans(current_text)
+        def replace_include_with_spans(match):
+            if _intersects_any_span(match.start(), match.end(), code_spans):
+                return match.group(0)
+            return replace_include(match)
+        current_text = re.sub(pattern, replace_include_with_spans, current_text, flags=re.DOTALL)
     return current_text
 
 def process_pdd_tags(text: str) -> str:
@@ -262,7 +299,12 @@ def process_shell_tags(text: str, recursive: bool) -> str:
             console.print(f"[bold red]Error executing shell command:[/bold red] {str(e)}")
             _dbg(f"Shell execution exception: {e}")
             return f"[Shell execution error: {str(e)}]"
-    return re.sub(pattern, replace_shell, text, flags=re.DOTALL)
+    code_spans = _extract_code_spans(text)
+    def replace_shell_with_spans(match):
+        if _intersects_any_span(match.start(), match.end(), code_spans):
+            return match.group(0)
+        return replace_shell(match)
+    return re.sub(pattern, replace_shell_with_spans, text, flags=re.DOTALL)
 
 def process_web_tags(text: str, recursive: bool) -> str:
     pattern = r'<web>(.*?)</web>'
@@ -275,7 +317,7 @@ def process_web_tags(text: str, recursive: bool) -> str:
         _dbg(f"Web tag URL: {url}")
         try:
             try:
-                from firecrawl import FirecrawlApp
+                from firecrawl import Firecrawl
             except ImportError:
                 _dbg("firecrawl import failed; package not installed")
                 return f"[Error: firecrawl-py package not installed. Cannot scrape {url}]"
@@ -284,9 +326,13 @@ def process_web_tags(text: str, recursive: bool) -> str:
                 console.print("[bold yellow]Warning:[/bold yellow] FIRECRAWL_API_KEY not found in environment")
                 _dbg("FIRECRAWL_API_KEY not set")
                 return f"[Error: FIRECRAWL_API_KEY not set. Cannot scrape {url}]"
-            app = FirecrawlApp(api_key=api_key)
-            response = app.scrape_url(url, formats=['markdown'])
-            if hasattr(response, 'markdown'):
+            app = Firecrawl(api_key=api_key)
+            response = app.scrape(url, formats=['markdown'])
+            # Handle both dict response (new API) and object response (legacy)
+            if isinstance(response, dict) and 'markdown' in response:
+                _dbg(f"Web scrape returned markdown (len={len(response['markdown'])})")
+                return response['markdown']
+            elif hasattr(response, 'markdown'):
                 _dbg(f"Web scrape returned markdown (len={len(response.markdown)})")
                 return response.markdown
             else:
@@ -297,7 +343,12 @@ def process_web_tags(text: str, recursive: bool) -> str:
             console.print(f"[bold red]Error scraping web content:[/bold red] {str(e)}")
             _dbg(f"Web scraping exception: {e}")
             return f"[Web scraping error: {str(e)}]"
-    return re.sub(pattern, replace_web, text, flags=re.DOTALL)
+    code_spans = _extract_code_spans(text)
+    def replace_web_with_spans(match):
+        if _intersects_any_span(match.start(), match.end(), code_spans):
+            return match.group(0)
+        return replace_web(match)
+    return re.sub(pattern, replace_web_with_spans, text, flags=re.DOTALL)
 
 def process_include_many_tags(text: str, recursive: bool) -> str:
     """Process <include-many> blocks whose inner content is a comma- or newline-separated
@@ -328,7 +379,12 @@ def process_include_many_tags(text: str, recursive: bool) -> str:
                 _dbg(f"Error processing include-many {p}: {e}")
                 contents.append(f"[Error processing include: {p}]")
         return "\n".join(contents)
-    return re.sub(pattern, replace_many, text, flags=re.DOTALL)
+    code_spans = _extract_code_spans(text)
+    def replace_many_with_spans(match):
+        if _intersects_any_span(match.start(), match.end(), code_spans):
+            return match.group(0)
+        return replace_many(match)
+    return re.sub(pattern, replace_many_with_spans, text, flags=re.DOTALL)
 
 def double_curly(text: str, exclude_keys: Optional[List[str]] = None) -> str:
     if exclude_keys is None:

pdd/preprocess_main.py

@@ -1,5 +1,6 @@
 import csv
 import sys
+from pathlib import Path
 from typing import Tuple, Optional
 import click
 from rich import print as rprint
@@ -8,8 +9,15 @@ from .config_resolution import resolve_effective_config
 from .construct_paths import construct_paths
 from .preprocess import preprocess
 from .xml_tagger import xml_tagger
+from .architecture_sync import (
+    get_architecture_entry_for_prompt,
+    generate_tags_from_architecture,
+    has_pdd_tags,
+)
+
+
 def preprocess_main(
-    ctx: click.Context, prompt_file: str, output: Optional[str], xml: bool, recursive: bool, double: bool, exclude: list
+    ctx: click.Context, prompt_file: str, output: Optional[str], xml: bool, recursive: bool, double: bool, exclude: list, pdd_tags: bool = False
 ) -> Tuple[str, float, str]:
     """
     CLI wrapper for preprocessing prompts.
@@ -22,6 +30,7 @@ def preprocess_main(
     :param double: If True, curly brackets will be doubled.
     :param exclude: List of keys to exclude from curly bracket doubling.
     :return: Tuple containing the preprocessed prompt, total cost, and model name used.
+    :param pdd_tags: If True, inject PDD metadata tags from architecture.json.
     """
     try:
         # Construct file paths
@@ -39,6 +48,27 @@ def preprocess_main(
         # Load prompt file
         prompt = input_strings["prompt_file"]
 
+        # Inject PDD metadata tags from architecture.json if requested
+        pdd_tags_injected = False
+        if pdd_tags:
+            prompt_filename = Path(prompt_file).name
+            arch_entry = get_architecture_entry_for_prompt(prompt_filename)
+
+            if arch_entry:
+                if has_pdd_tags(prompt):
+                    if not ctx.obj.get("quiet", False):
+                        rprint(f"[yellow]Prompt already has PDD tags, skipping injection.[/yellow]")
+                else:
+                    generated_tags = generate_tags_from_architecture(arch_entry)
+                    if generated_tags:
+                        prompt = generated_tags + '\n\n' + prompt
+                        pdd_tags_injected = True
+                        if not ctx.obj.get("quiet", False):
+                            rprint(f"[green]Injected PDD tags from architecture.json[/green]")
+            else:
+                if not ctx.obj.get("quiet", False):
+                    rprint(f"[yellow]No architecture entry found for '{prompt_filename}', skipping PDD tags.[/yellow]")
+
         if xml:
             # Use xml_tagger to add XML delimiters
             # Use centralized config resolution with proper priority: CLI > pddrc > defaults
@@ -67,6 +97,8 @@ def preprocess_main(
         # Provide user feedback
         if not ctx.obj.get("quiet", False):
             rprint("[bold green]Prompt preprocessing completed successfully.[/bold green]")
+            if pdd_tags_injected:
+                rprint("[bold]PDD metadata tags: injected from architecture.json[/bold]")
             if xml:
                 rprint(f"[bold]XML Tagging used: {model_name}[/bold]")
             else:

pdd/prompts/agentic_bug_step10_pr_LLM.prompt

@@ -0,0 +1,182 @@
+% You are an expert software engineer investigating a bug report. Your task is to create a draft pull request with the failing tests and link it to the issue.
+
+% Context
+
+You are working on step 10 of 10 (final step) in an agentic bug investigation workflow. Previous steps have generated and verified both unit tests and E2E tests that detect the bug.
+
+% Inputs
+
+- GitHub Issue URL: {issue_url}
+- Repository: {repo_owner}/{repo_name}
+- Issue Number: {issue_number}
+
+% Issue Content
+<issue_content>
+{issue_content}
+</issue_content>
+
+% Previous Steps Output
+<step1_output>
+{step1_output}
+</step1_output>
+
+<step2_output>
+{step2_output}
+</step2_output>
+
+<step3_output>
+{step3_output}
+</step3_output>
+
+<step4_output>
+{step4_output}
+</step4_output>
+
+<step5_output>
+{step5_output}
+</step5_output>
+
+<step6_output>
+{step6_output}
+</step6_output>
+
+<step7_output>
+{step7_output}
+</step7_output>
+
+<step8_output>
+{step8_output}
+</step8_output>
+
+<step9_output>
+{step9_output}
+</step9_output>
+
+% Worktree Information
+
+You are operating in an isolated git worktree at: {worktree_path}
+This worktree is already checked out to branch `fix/issue-{issue_number}`.
+Do NOT create a new branch - just stage, commit, and push.
+
+% Files to Stage
+
+**IMPORTANT: Only stage these specific files:**
+{files_to_stage}
+
+% Your Task
+
+1. **Prepare the commit**
+   - You are already on branch `fix/issue-{issue_number}` in an isolated worktree
+   - **CRITICAL: Stage ONLY the test file(s) created in Steps 7 and 9**
+   - Get the exact file paths from:
+     - Step 7's `FILES_CREATED:` or `FILES_MODIFIED:` output (unit tests)
+     - Step 9's `E2E_FILES_CREATED:` or `E2E_FILES_MODIFIED:` output (E2E tests)
+   - Stage each file individually: `git add <exact_file_path>`
+   - **DO NOT use `git add .` or `git add -A`** - these will stage unrelated files and pollute the PR
+   - Verify only the intended files are staged: `git status --short` (should show only the test file(s))
+   - Commit with a descriptive message referencing the issue
+
+2. **Create the draft PR**
+   - Push the branch to origin
+   - Create a draft pull request using `gh pr create --draft`
+   - Link to the issue using "Fixes #{issue_number}" in the PR body
+
+3. **Post final summary**
+   - Comment on the issue with PR link and next steps for the fix
+
+4. **Include PDD fix command**
+   - Extract code file path from Step 5's `**Location:**` field (strip the `:line_number` suffix)
+   - Use test file path from Step 7's `FILES_CREATED:` or test file section
+   - Search repo for matching prompt file: `find . -name "*.prompt" -type f`
+   - Derive module name from code file (e.g., `pdd/foo.py` -> `foo`)
+   - Use verification program: `context/{{module_name}}_example.py`
+   - Use error log path: `fix-issue-{issue_number}.log` for the fix command output
+   - Include a ready-to-run `pdd fix` command in your GitHub comment
+   - If no prompt file or verification program exists, include a note that they must be created first
+
+% PR Creation Command
+
+```bash
+gh pr create --draft --title "Add failing tests for #{issue_number}" --body "$(cat <<'EOF'
+## Summary
+Adds failing tests that detect the bug reported in #{issue_number}.
+
+## Test Files
+- Unit test: `{{unit_test_file_path}}`
+- E2E test: `{{e2e_test_file_path}}` (if applicable)
+
+## What This PR Contains
+- Failing unit test that reproduces the reported bug
+- Failing E2E test that verifies the bug at integration level (if applicable)
+- Tests are verified to fail on current code and will pass once the bug is fixed
+
+## Root Cause
+{{root_cause_summary}}
+
+## Next Steps
+1. [ ] Implement the fix at the identified location
+2. [ ] Verify the unit test passes
+3. [ ] Verify the E2E test passes
+4. [ ] Run full test suite
+5. [ ] Mark PR as ready for review
+
+Fixes #{issue_number}
+
+---
+*Generated by PDD agentic bug workflow*
+EOF
+)"
+```
+
+% Output
+
+After creating the PR, use `gh issue comment` to post your final report to issue #{issue_number}:
+
+```
+gh issue comment {issue_number} --repo {repo_owner}/{repo_name} --body "..."
+```
+
+Your comment should follow this format:
+
+```markdown
+## Step 10: Draft PR Created
+
+### Pull Request
+**PR #{{pr_number}}:** [{{pr_title}}]({{pr_url}})
+
+### Branch
+`fix/issue-{issue_number}`
+
+### What's Included
+- Failing unit test at `{{unit_test_file_path}}`
+- Failing E2E test at `{{e2e_test_file_path}}` (if applicable)
+- Commits: {{commit_count}}
+
+### Next Steps for Maintainers
+1. Review the failing tests to understand the expected behavior
+2. Implement the fix at the identified location
+3. Verify both unit and E2E tests pass with your fix
+4. Run full test suite to check for regressions
+5. Mark the PR as ready for review
+
+### PDD Fix Command
+
+To auto-fix this bug using PDD:
+
+```bash
+cd {{worktree_path}}
+pdd --force fix --loop --max-attempts 5 --verification-program context/{{module_name}}_example.py {{prompt_file}} {{code_file_path}} {{test_file_path}} fix-issue-{{issue_number}}.log
+```
+
+---
+*Investigation complete. A draft PR with failing tests has been created and linked to this issue.*
+```
+
+% Important
+
+- Create a DRAFT PR (not ready for review) since it only contains the failing tests
+- The PR should clearly state that a fix is still needed
+- Use "Fixes #{issue_number}" to auto-link the PR to the issue
+- Do NOT create a new branch - you are already on the correct branch in the worktree
+- Include both unit test files (Step 7) and E2E test files (Step 9) if both exist
+- Always post your findings as a GitHub comment before completing