pdd-cli 0.0.45__py3-none-any.whl → 0.0.118__py3-none-any.whl

pdd/sync_determine_operation.py

@@ -11,6 +11,7 @@ import sys
 import json
 import hashlib
 import subprocess
+import fnmatch
 from pathlib import Path
 from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Any
@@ -31,10 +32,17 @@ except ImportError:
     HAS_MSVCRT = False
 
 # Import PDD internal modules
-from pdd.construct_paths import construct_paths
+from pdd.construct_paths import (
+    _detect_context,
+    _find_pddrc_file,
+    _get_relative_basename,
+    _load_pddrc_config,
+    construct_paths,
+)
 from pdd.load_prompt_template import load_prompt_template
 from pdd.llm_invoke import llm_invoke
 from pdd.get_language import get_language
+from pdd.template_expander import expand_template
 
 # Constants - Use functions for dynamic path resolution
 def get_pdd_dir():
@@ -55,11 +63,41 @@ META_DIR = get_meta_dir()
 LOCKS_DIR = get_locks_dir()
 
 # Export constants for other modules
-__all__ = ['PDD_DIR', 'META_DIR', 'LOCKS_DIR', 'Fingerprint', 'RunReport', 'SyncDecision', 
+__all__ = ['PDD_DIR', 'META_DIR', 'LOCKS_DIR', 'Fingerprint', 'RunReport', 'SyncDecision',
            'sync_determine_operation', 'analyze_conflict_with_llm', 'read_run_report', 'get_pdd_file_paths',
            '_check_example_success_history']
 
 
+def _safe_basename(basename: str) -> str:
+    """Sanitize basename for use in metadata filenames.
+
+    Replaces '/' with '_' to prevent path interpretation when the basename
+    contains subdirectory components (e.g., 'core/cloud' -> 'core_cloud').
+    """
+    return basename.replace('/', '_')
+
+
+def _extract_name_part(basename: str) -> tuple:
+    """Extract directory and name parts from a subdirectory basename.
+
+    For subdirectory basenames like 'core/cloud', separates the directory
+    prefix from the actual name so that filename patterns can be applied
+    correctly.
+
+    Args:
+        basename: The full basename, possibly containing subdirectory path.
+
+    Returns:
+        Tuple of (dir_prefix, name_part):
+        - 'core/cloud' -> ('core/', 'cloud')
+        - 'calculator' -> ('', 'calculator')
+    """
+    if '/' in basename:
+        dir_part, name_part = basename.rsplit('/', 1)
+        return dir_part + '/', name_part
+    return '', basename
+
+
 @dataclass
 class Fingerprint:
     """Represents the last known good state of a PDD unit."""
@@ -69,7 +107,8 @@ class Fingerprint:
     prompt_hash: Optional[str]
     code_hash: Optional[str]
     example_hash: Optional[str]
-    test_hash: Optional[str]
+    test_hash: Optional[str]  # Keep for backward compat (primary test file)
+    test_files: Optional[Dict[str, str]] = None  # Bug #156: {"test_foo.py": "hash1", ...}
 
 
 @dataclass
@@ -80,6 +119,8 @@ class RunReport:
     tests_passed: int
     tests_failed: int
     coverage: float
+    test_hash: Optional[str] = None  # Hash of test file when tests were run (for staleness detection)
+    test_files: Optional[Dict[str, str]] = None  # Bug #156: {"test_foo.py": "hash1", ...}
 
 
 @dataclass
@@ -99,7 +140,7 @@ class SyncLock:
     def __init__(self, basename: str, language: str):
         self.basename = basename
         self.language = language
-        self.lock_file = get_locks_dir() / f"{basename}_{language}.lock"
+        self.lock_file = get_locks_dir() / f"{_safe_basename(basename)}_{language}.lock"
         self.fd = None
         self.current_pid = os.getpid()
     
@@ -209,51 +250,363 @@ def get_extension(language: str) -> str:
     return extensions.get(language.lower(), language.lower())
 
 
-def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts") -> Dict[str, Path]:
+def _resolve_prompts_root(prompts_dir: str) -> Path:
+    """Resolve prompts root relative to the .pddrc location when available."""
+    prompts_root = Path(prompts_dir)
+    pddrc_path = _find_pddrc_file()
+    if pddrc_path and not prompts_root.is_absolute():
+        prompts_root = pddrc_path.parent / prompts_root
+
+    parts = prompts_root.parts
+    if "prompts" in parts:
+        prompt_index = parts.index("prompts")
+        prompts_root = Path(*parts[: prompt_index + 1])
+
+    return prompts_root
+
+
+def _relative_basename_for_context(basename: str, context_name: Optional[str]) -> str:
+    """Strip context-specific prefixes from basename when possible."""
+    if not context_name:
+        return basename
+
+    pddrc_path = _find_pddrc_file()
+    if not pddrc_path:
+        return basename
+
+    try:
+        config = _load_pddrc_config(pddrc_path)
+    except ValueError:
+        return basename
+
+    contexts = config.get("contexts", {})
+    context_config = contexts.get(context_name, {})
+    defaults = context_config.get("defaults", {})
+
+    matches = []
+
+    prompts_dir = defaults.get("prompts_dir", "")
+    if prompts_dir:
+        normalized = prompts_dir.rstrip("/")
+        prefix = normalized
+        if normalized == "prompts":
+            prefix = ""
+        elif normalized.startswith("prompts/"):
+            prefix = normalized[len("prompts/"):]
+
+        if prefix and (basename == prefix or basename.startswith(prefix + "/")):
+            relative = basename[len(prefix) + 1 :] if basename != prefix else basename.split("/")[-1]
+            matches.append((len(prefix), relative))
+
+    for pattern in context_config.get("paths", []):
+        pattern_base = pattern.rstrip("/**").rstrip("/*")
+        if fnmatch.fnmatch(basename, pattern) or \
+           basename.startswith(pattern_base + "/") or \
+           basename == pattern_base:
+            relative = _get_relative_basename(basename, pattern)
+            matches.append((len(pattern_base), relative))
+
+    if not matches:
+        return basename
+
+    matches.sort(key=lambda item: item[0], reverse=True)
+    return matches[0][1]
+
+
+def _generate_paths_from_templates(
+    basename: str,
+    language: str,
+    extension: str,
+    outputs_config: Dict[str, Any],
+    prompt_path: str
+) -> Dict[str, Path]:
+    """
+    Generate file paths from template configuration.
+
+    This function is used by Issue #237 to support extensible output path patterns
+    for different project layouts (Next.js, Vue, Python backend, etc.).
+
+    Args:
+        basename: The relative basename (e.g., 'marketplace/AssetCard' or 'credit_helpers')
+        language: The full language name (e.g., 'python', 'typescript')
+        extension: The file extension (e.g., 'py', 'tsx')
+        outputs_config: The 'outputs' section from .pddrc context config
+        prompt_path: The prompt file path to use as fallback
+
+    Returns:
+        Dictionary mapping file types ('prompt', 'code', 'test', etc.) to Path objects
+    """
+    import logging
+    logger = logging.getLogger(__name__)
+
+    # Extract name parts for template context
+    parts = basename.split('/')
+    name = parts[-1] if parts else basename
+    category = '/'.join(parts[:-1]) if len(parts) > 1 else ''
+
+    # Build dir_prefix (for legacy template compatibility)
+    dir_prefix = '/'.join(parts[:-1]) + '/' if len(parts) > 1 else ''
+
+    # Build template context
+    template_context = {
+        'name': name,
+        'category': category,
+        'dir_prefix': dir_prefix,
+        'ext': extension,
+        'language': language,
+    }
+
+    logger.debug(f"Template context: {template_context}")
+
+    result = {}
+
+    # Expand templates for each output type
+    for output_type, config in outputs_config.items():
+        if isinstance(config, dict) and 'path' in config:
+            template = config['path']
+            expanded = expand_template(template, template_context)
+            result[output_type] = Path(expanded)
+            logger.debug(f"Template {output_type}: {template} -> {expanded}")
+
+    # Ensure prompt is always present (fallback to provided prompt_path)
+    if 'prompt' not in result:
+        result['prompt'] = Path(prompt_path)
+
+    # Handle test_files for Bug #156 compatibility
+    if 'test' in result:
+        test_path = result['test']
+        test_dir_path = test_path.parent
+        test_stem = f"test_{name}"
+        if test_dir_path.exists():
+            matching_test_files = sorted(test_dir_path.glob(f"{test_stem}*.{extension}"))
+        else:
+            matching_test_files = [test_path] if test_path.exists() else []
+        result['test_files'] = matching_test_files or [test_path]
+
+    return result
+
+
+def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts", context_override: Optional[str] = None) -> Dict[str, Path]:
     """Returns a dictionary mapping file types to their expected Path objects."""
+    import logging
+    logger = logging.getLogger(__name__)
+    logger.info(f"get_pdd_file_paths called: basename={basename}, language={language}, prompts_dir={prompts_dir}")
+    
     try:
         # Use construct_paths to get configuration-aware paths
+        prompts_root = _resolve_prompts_root(prompts_dir)
         prompt_filename = f"{basename}_{language}.prompt"
-        prompt_path = str(Path(prompts_dir) / prompt_filename)
+        prompt_path = str(prompts_root / prompt_filename)
+        pddrc_path = _find_pddrc_file()
+        if pddrc_path:
+            try:
+                config = _load_pddrc_config(pddrc_path)
+                context_name = context_override or _detect_context(Path.cwd(), config, None)
+                context_config = config.get('contexts', {}).get(context_name or '', {})
+                prompts_dir_config = context_config.get('defaults', {}).get('prompts_dir', '')
+                if prompts_dir_config:
+                    normalized = prompts_dir_config.rstrip('/')
+                    prefix = normalized
+                    if normalized == 'prompts':
+                        prefix = ''
+                    elif normalized.startswith('prompts/'):
+                        prefix = normalized[len('prompts/'):]
+                    if prefix and not (basename == prefix or basename.startswith(prefix + '/')):
+                        prompt_path = str(prompts_root / prefix / prompt_filename)
+            except ValueError:
+                pass
+        logger.info(f"Checking prompt_path={prompt_path}, exists={Path(prompt_path).exists()}")
         
-        # Check if prompt file exists - if not, we can't proceed with construct_paths
+        # Check if prompt file exists - if not, we still need configuration-aware paths
         if not Path(prompt_path).exists():
-            # Fall back to default path construction if prompt doesn't exist
+            # Use construct_paths with minimal inputs to get configuration-aware paths
+            # even when prompt doesn't exist
             extension = get_extension(language)
-            return {
-                'prompt': Path(prompt_path),
-                'code': Path(f"{basename}.{extension}"),
-                'example': Path(f"{basename}_example.{extension}"),
-                'test': Path(f"test_{basename}.{extension}")
-            }
+            try:
+                # Call construct_paths with empty input_file_paths to get configured output paths
+                resolved_config, _, output_paths, _ = construct_paths(
+                    input_file_paths={},  # Empty dict since files don't exist yet
+                    force=True,
+                    quiet=True,
+                    command="sync",
+                    command_options={"basename": basename, "language": language},
+                    context_override=context_override,
+                    path_resolution_mode="cwd"
+                )
+
+                import logging
+                logger = logging.getLogger(__name__)
+                logger.info(f"resolved_config: {resolved_config}")
+                logger.info(f"output_paths: {output_paths}")
+
+                # Issue #237: Check for 'outputs' config for template-based path generation
+                outputs_config = resolved_config.get('outputs')
+                if outputs_config:
+                    logger.info(f"Using template-based paths from outputs config")
+                    context_name = context_override or resolved_config.get('_matched_context')
+                    basename_for_templates = _relative_basename_for_context(basename, context_name)
+                    result = _generate_paths_from_templates(
+                        basename=basename_for_templates,
+                        language=language,
+                        extension=extension,
+                        outputs_config=outputs_config,
+                        prompt_path=prompt_path
+                    )
+                    logger.debug(f"get_pdd_file_paths returning (template-based): {result}")
+                    return result
+
+                # Legacy path construction (backwards compatibility)
+                # Extract directory configuration from resolved_config
+                # Note: construct_paths sets tests_dir, examples_dir, code_dir keys
+                test_dir = resolved_config.get('tests_dir', 'tests/')
+                example_dir = resolved_config.get('examples_dir', 'examples/')
+                code_dir = resolved_config.get('code_dir', './')
+
+                logger.info(f"Extracted dirs - test: {test_dir}, example: {example_dir}, code: {code_dir}")
+
+                # Ensure directories end with /
+                if test_dir and not test_dir.endswith('/'):
+                    test_dir = test_dir + '/'
+                if example_dir and not example_dir.endswith('/'):
+                    example_dir = example_dir + '/'
+                if code_dir and not code_dir.endswith('/'):
+                    code_dir = code_dir + '/'
+
+                # Extract directory and name parts for subdirectory basename support
+                dir_prefix, name_part = _extract_name_part(basename)
+
+                # Get explicit config paths (these are the SOURCE OF TRUTH when configured)
+                # These should be used directly, NOT combined with dir_prefix
+                generate_output_path = resolved_config.get('generate_output_path', '')
+                example_output_path = resolved_config.get('example_output_path', '')
+                test_output_path = resolved_config.get('test_output_path', '')
+
+                # Construct paths: use explicit config paths directly when configured,
+                # otherwise fall back to old behavior with dir_prefix for backwards compat
+
+                # Code path
+                if generate_output_path and generate_output_path.endswith('/'):
+                    # Explicit complete directory - use directly with just filename
+                    code_path = f"{generate_output_path}{name_part}.{extension}"
+                else:
+                    # Old behavior - use code_dir + dir_prefix
+                    code_path = f"{code_dir}{dir_prefix}{name_part}.{extension}"
+
+                # Example path
+                if example_output_path and example_output_path.endswith('/'):
+                    # Explicit complete directory - use directly with just filename
+                    example_path = f"{example_output_path}{name_part}_example.{extension}"
+                else:
+                    # Old behavior - use example_dir + dir_prefix
+                    example_path = f"{example_dir}{dir_prefix}{name_part}_example.{extension}"
+
+                # Test path
+                if test_output_path and test_output_path.endswith('/'):
+                    # Explicit complete directory - use directly with just filename
+                    test_path = f"{test_output_path}test_{name_part}.{extension}"
+                else:
+                    # Old behavior - use test_dir + dir_prefix
+                    test_path = f"{test_dir}{dir_prefix}test_{name_part}.{extension}"
+
+                logger.debug(f"Final paths: test={test_path}, example={example_path}, code={code_path}")
+
+                # Convert to Path objects
+                test_path = Path(test_path)
+                example_path = Path(example_path)
+                code_path = Path(code_path)
+
+                # Bug #156: Find all matching test files
+                test_dir_path = test_path.parent
+                test_stem = f"test_{name_part}"
+                if test_dir_path.exists():
+                    matching_test_files = sorted(test_dir_path.glob(f"{test_stem}*.{extension}"))
+                else:
+                    matching_test_files = [test_path] if test_path.exists() else []
+
+                result = {
+                    'prompt': Path(prompt_path),
+                    'code': code_path,
+                    'example': example_path,
+                    'test': test_path,
+                    'test_files': matching_test_files or [test_path]  # Bug #156
+                }
+                logger.debug(f"get_pdd_file_paths returning (prompt missing): test={test_path}")
+                return result
+            except Exception as e:
+                # If construct_paths fails, fall back to current directory paths
+                # This maintains backward compatibility
+                import logging
+                logger = logging.getLogger(__name__)
+                logger.debug(f"construct_paths failed for non-existent prompt, using defaults: {e}")
+                dir_prefix, name_part = _extract_name_part(basename)
+                fallback_test_path = Path(f"{dir_prefix}test_{name_part}.{extension}")
+                # Bug #156: Find matching test files even in fallback
+                if Path('.').exists():
+                    fallback_matching = sorted(Path('.').glob(f"{dir_prefix}test_{name_part}*.{extension}"))
+                else:
+                    fallback_matching = [fallback_test_path] if fallback_test_path.exists() else []
+                return {
+                    'prompt': Path(prompt_path),
+                    'code': Path(f"{dir_prefix}{name_part}.{extension}"),
+                    'example': Path(f"{dir_prefix}{name_part}_example.{extension}"),
+                    'test': fallback_test_path,
+                    'test_files': fallback_matching or [fallback_test_path]  # Bug #156
+                }
         
         input_file_paths = {
             "prompt_file": prompt_path
         }
         
-        # Only call construct_paths if the prompt file exists
+        # Call construct_paths to get configuration-aware paths
         resolved_config, input_strings, output_file_paths, detected_language = construct_paths(
             input_file_paths=input_file_paths,
             force=True,  # Use force=True to avoid interactive prompts during sync
             quiet=True,
-            command="generate",
-            command_options={}
+            command="sync",  # Use sync command to get more tolerant path handling
+            command_options={"basename": basename, "language": language},
+            context_override=context_override,
+            path_resolution_mode="cwd"
         )
-        
-        # Extract paths from config as specified in the spec
-        # The spec shows: return { 'prompt': Path(config['prompt_file']), ... }
-        # But we need to map the output_file_paths keys to our expected structure
-        
-        # For generate command, construct_paths returns these in output_file_paths:
-        # - 'output' or 'code_file' for the generated code
-        # For other commands, we need to construct the full set of paths
-        
-        # Get the code file path from output_file_paths
-        code_path = output_file_paths.get('output', output_file_paths.get('code_file', ''))
+
+        # Issue #237: Check for 'outputs' config for template-based path generation
+        # This must be checked even when prompt EXISTS (not just when it doesn't exist)
+        outputs_config = resolved_config.get('outputs')
+        if outputs_config:
+            extension = get_extension(language)
+            logger.info(f"Using template-based paths from outputs config (prompt exists)")
+            context_name = context_override or resolved_config.get('_matched_context')
+            basename_for_templates = _relative_basename_for_context(basename, context_name)
+            result = _generate_paths_from_templates(
+                basename=basename_for_templates,
+                language=language,
+                extension=extension,
+                outputs_config=outputs_config,
+                prompt_path=prompt_path
+            )
+            logger.debug(f"get_pdd_file_paths returning (template-based, prompt exists): {result}")
+            return result
+
+        # For sync command, output_file_paths contains the configured paths
+        # Extract the code path from output_file_paths
+        code_path = output_file_paths.get('generate_output_path', '')
+        if not code_path:
+            # Try other possible keys
+            code_path = output_file_paths.get('output', output_file_paths.get('code_file', ''))
         if not code_path:
-            # Fallback to constructing from basename
+            # Fallback to constructing from basename with configuration
             extension = get_extension(language)
-            code_path = f"{basename}.{extension}"
+            generate_output_path = resolved_config.get('generate_output_path', '')
+            dir_prefix, name_part = _extract_name_part(basename)
+
+            # Use explicit config path directly when configured (ending with /)
+            if generate_output_path and generate_output_path.endswith('/'):
+                code_path = f"{generate_output_path}{name_part}.{extension}"
+            else:
+                # Old behavior - use path + dir_prefix
+                code_dir = generate_output_path or './'
+                if not code_dir.endswith('/'):
+                    code_dir = code_dir + '/'
+                code_path = f"{code_dir}{dir_prefix}{name_part}.{extension}"
         
         # Get configured paths for example and test files using construct_paths
         # Note: construct_paths requires files to exist, so we need to handle the case
@@ -269,18 +622,32 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
             
             try:
                 # Get example path using example command
+                # Pass path_resolution_mode="cwd" so paths resolve relative to CWD (not project root)
+                # Pass basename in command_options to preserve subdirectory structure
                 _, _, example_output_paths, _ = construct_paths(
                     input_file_paths={"prompt_file": prompt_path, "code_file": code_path},
-                    force=True, quiet=True, command="example", command_options={}
-                )
-                example_path = Path(example_output_paths.get('output', f"{basename}_example.{get_extension(language)}"))
-                
-                # Get test path using test command  
-                _, _, test_output_paths, _ = construct_paths(
-                    input_file_paths={"prompt_file": prompt_path, "code_file": code_path},
-                    force=True, quiet=True, command="test", command_options={}
+                    force=True, quiet=True, command="example",
+                    command_options={"basename": basename},
+                    context_override=context_override,
+                    path_resolution_mode="cwd"
                 )
-                test_path = Path(test_output_paths.get('output', f"test_{basename}.{get_extension(language)}"))
+                dir_prefix, name_part = _extract_name_part(basename)
+                example_path = Path(example_output_paths.get('output', f"{dir_prefix}{name_part}_example.{get_extension(language)}"))
+
+                # Get test path using test command - handle case where test file doesn't exist yet
+                # Pass basename in command_options to preserve subdirectory structure
+                try:
+                    _, _, test_output_paths, _ = construct_paths(
+                        input_file_paths={"prompt_file": prompt_path, "code_file": code_path},
+                        force=True, quiet=True, command="test",
+                        command_options={"basename": basename},
+                        context_override=context_override,
+                        path_resolution_mode="cwd"
+                    )
+                    test_path = Path(test_output_paths.get('output', f"{dir_prefix}test_{name_part}.{get_extension(language)}"))
+                except FileNotFoundError:
+                    # Test file doesn't exist yet - create default path
+                    test_path = Path(f"{dir_prefix}test_{name_part}.{get_extension(language)}")
                 
             finally:
                 # Clean up temporary file if we created it
@@ -298,17 +665,30 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
             # Improved fallback: try to use construct_paths with just prompt_file to get proper directory configs
             try:
                 # Get configured directories by using construct_paths with just the prompt file
+                # Pass path_resolution_mode="cwd" so paths resolve relative to CWD (not project root)
+                # Pass basename in command_options to preserve subdirectory structure
                 _, _, example_output_paths, _ = construct_paths(
                     input_file_paths={"prompt_file": prompt_path},
-                    force=True, quiet=True, command="example", command_options={}
+                    force=True, quiet=True, command="example",
+                    command_options={"basename": basename},
+                    context_override=context_override,
+                    path_resolution_mode="cwd"
                 )
-                example_path = Path(example_output_paths.get('output', f"{basename}_example.{get_extension(language)}"))
-                
-                _, _, test_output_paths, _ = construct_paths(
-                    input_file_paths={"prompt_file": prompt_path},
-                    force=True, quiet=True, command="test", command_options={}
-                )
-                test_path = Path(test_output_paths.get('output', f"test_{basename}.{get_extension(language)}"))
+                dir_prefix, name_part = _extract_name_part(basename)
+                example_path = Path(example_output_paths.get('output', f"{dir_prefix}{name_part}_example.{get_extension(language)}"))
+
+                try:
+                    _, _, test_output_paths, _ = construct_paths(
+                        input_file_paths={"prompt_file": prompt_path},
+                        force=True, quiet=True, command="test",
+                        command_options={"basename": basename},
+                        context_override=context_override,
+                        path_resolution_mode="cwd"
+                    )
+                    test_path = Path(test_output_paths.get('output', f"{dir_prefix}test_{name_part}.{get_extension(language)}"))
+                except Exception:
+                    # If test path construction fails, use default naming
+                    test_path = Path(f"{dir_prefix}test_{name_part}.{get_extension(language)}")
                 
             except Exception:
                 # Final fallback to deriving from code path if all else fails
@@ -319,21 +699,50 @@ def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts
                 example_path = code_dir / f"{code_stem}_example{code_ext}"
                 test_path = code_dir / f"test_{code_stem}{code_ext}"
         
+        # Ensure all paths are Path objects
+        if isinstance(code_path, str):
+            code_path = Path(code_path)
+        
+        # Keep paths as they are (absolute or relative as returned by construct_paths)
+        # This ensures consistency with how construct_paths expects them
+
+        # Bug #156: Find all matching test files
+        test_dir = test_path.parent
+        _, name_part_for_glob = _extract_name_part(basename)
+        test_stem = f"test_{name_part_for_glob}"
+        extension = get_extension(language)
+        if test_dir.exists():
+            matching_test_files = sorted(test_dir.glob(f"{test_stem}*.{extension}"))
+        else:
+            matching_test_files = [test_path] if test_path.exists() else []
+
         return {
             'prompt': Path(prompt_path),
-            'code': Path(code_path),
+            'code': code_path,
             'example': example_path,
-            'test': test_path
+            'test': test_path,
+            'test_files': matching_test_files or [test_path]  # Bug #156: All matching test files
         }
-        
+
     except Exception as e:
         # Fallback to simple naming if construct_paths fails
         extension = get_extension(language)
+        dir_prefix, name_part = _extract_name_part(basename)
+        test_path = Path(f"{dir_prefix}test_{name_part}.{extension}")
+        # Bug #156: Try to find matching test files even in fallback
+        test_dir = Path('.')
+        test_stem = f"{dir_prefix}test_{name_part}"
+        if test_dir.exists():
+            matching_test_files = sorted(test_dir.glob(f"{test_stem}*.{extension}"))
+        else:
+            matching_test_files = [test_path] if test_path.exists() else []
+        prompts_root = _resolve_prompts_root(prompts_dir)
         return {
-            'prompt': Path(prompts_dir) / f"{basename}_{language}.prompt",
-            'code': Path(f"{basename}.{extension}"),
-            'example': Path(f"{basename}_example.{extension}"),
-            'test': Path(f"test_{basename}.{extension}")
+            'prompt': prompts_root / f"{basename}_{language}.prompt",
+            'code': Path(f"{dir_prefix}{name_part}.{extension}"),
+            'example': Path(f"{dir_prefix}{name_part}_example.{extension}"),
+            'test': test_path,
+            'test_files': matching_test_files or [test_path]  # Bug #156: All matching test files
         }
 
 
@@ -356,7 +765,7 @@ def read_fingerprint(basename: str, language: str) -> Optional[Fingerprint]:
     """Reads and validates the JSON fingerprint file."""
     meta_dir = get_meta_dir()
     meta_dir.mkdir(parents=True, exist_ok=True)
-    fingerprint_file = meta_dir / f"{basename}_{language}.json"
+    fingerprint_file = meta_dir / f"{_safe_basename(basename)}_{language}.json"
     
     if not fingerprint_file.exists():
         return None
@@ -372,7 +781,8 @@ def read_fingerprint(basename: str, language: str) -> Optional[Fingerprint]:
             prompt_hash=data.get('prompt_hash'),
             code_hash=data.get('code_hash'),
             example_hash=data.get('example_hash'),
-            test_hash=data.get('test_hash')
+            test_hash=data.get('test_hash'),
+            test_files=data.get('test_files')  # Bug #156
         )
     except (json.JSONDecodeError, KeyError, IOError):
         return None
@@ -382,7 +792,7 @@ def read_run_report(basename: str, language: str) -> Optional[RunReport]:
     """Reads and validates the JSON run report file."""
     meta_dir = get_meta_dir()
     meta_dir.mkdir(parents=True, exist_ok=True)
-    run_report_file = meta_dir / f"{basename}_{language}_run.json"
+    run_report_file = meta_dir / f"{_safe_basename(basename)}_{language}_run.json"
     
     if not run_report_file.exists():
         return None
@@ -396,19 +806,29 @@ def read_run_report(basename: str, language: str) -> Optional[RunReport]:
             exit_code=data['exit_code'],
             tests_passed=data['tests_passed'],
             tests_failed=data['tests_failed'],
-            coverage=data['coverage']
+            coverage=data['coverage'],
+            test_hash=data.get('test_hash'),  # Optional for backward compatibility
+            test_files=data.get('test_files')  # Bug #156
         )
     except (json.JSONDecodeError, KeyError, IOError):
         return None
 
 
-def calculate_current_hashes(paths: Dict[str, Path]) -> Dict[str, Optional[str]]:
+def calculate_current_hashes(paths: Dict[str, Any]) -> Dict[str, Any]:
     """Computes the hashes for all current files on disk."""
     # Return hash keys that match what the fingerprint expects
-    return {
-        f"{file_type}_hash": calculate_sha256(file_path)
-        for file_type, file_path in paths.items()
-    }
+    hashes = {}
+    for file_type, file_path in paths.items():
+        if file_type == 'test_files':
+            # Bug #156: Calculate hashes for all test files
+            hashes['test_files'] = {
+                f.name: calculate_sha256(f)
+                for f in file_path
+                if isinstance(f, Path) and f.exists()
+            }
+        elif isinstance(file_path, Path):
+            hashes[f"{file_type}_hash"] = calculate_sha256(file_path)
+    return hashes
 
 
 def get_git_diff(file_path: Path) -> str:
@@ -438,6 +858,7 @@ def estimate_operation_cost(operation: str, language: str = "python") -> float:
         'crash': 0.40,
         'verify': 0.35,
         'test': 0.60,
+        'test_extend': 0.60,  # Same cost as test - generates additional tests
         'fix': 0.45,
         'update': 0.25,
         'analyze_conflict': 0.20,
@@ -591,24 +1012,103 @@ def _handle_missing_expected_files(
     )
 
 
-def _is_workflow_complete(paths: Dict[str, Path], skip_tests: bool = False, skip_verify: bool = False) -> bool:
+def _is_workflow_complete(paths: Dict[str, Path], skip_tests: bool = False, skip_verify: bool = False,
+                          basename: str = None, language: str = None) -> bool:
     """
     Check if workflow is complete considering skip flags.
-    
+
     Args:
         paths: Dict mapping file types to their expected Path objects
         skip_tests: If True, test files are not required for completion
         skip_verify: If True, verification operations are not required
-    
+        basename: Module basename (required for run_report check)
+        language: Module language (required for run_report check)
+
     Returns:
-        True if all required files exist for the current workflow configuration
+        True if all required files exist AND have been validated (run_report exists)
     """
     required_files = ['code', 'example']
-    
+
     if not skip_tests:
         required_files.append('test')
-        
-    return all(paths[f].exists() for f in required_files)
+
+    # Check all required files exist
+    if not all(paths[f].exists() for f in required_files):
+        return False
+
+    # Also check that run_report exists and code works (exit_code == 0)
+    # Without this, newly generated code would incorrectly be marked as "complete"
+    if basename and language:
+        run_report = read_run_report(basename, language)
+        if not run_report or run_report.exit_code != 0:
+            return False
+
+        # Check that run_report corresponds to current test files (staleness detection)
+        # If any test file changed since run_report was created, we can't trust the results
+        if not skip_tests:
+            # Bug #156: Check ALL test files, not just the primary one
+            if 'test_files' in paths and run_report.test_files:
+                # New multi-file comparison
+                current_test_hashes = {
+                    f.name: calculate_sha256(f)
+                    for f in paths['test_files']
+                    if f.exists()
+                }
+                stored_test_hashes = run_report.test_files
+
+                # Check if any test file changed or new ones added/removed
+                if set(current_test_hashes.keys()) != set(stored_test_hashes.keys()):
+                    return False  # Test files added or removed
+
+                for fname, current_hash in current_test_hashes.items():
+                    if stored_test_hashes.get(fname) != current_hash:
+                        return False  # Test file content changed
+            elif 'test' in paths and paths['test'].exists():
+                # Backward compat: single file check
+                current_test_hash = calculate_sha256(paths['test'])
+                if run_report.test_hash and current_test_hash != run_report.test_hash:
+                    # run_report was created for a different version of the test file
+                    return False
+                if not run_report.test_hash:
+                    # Legacy run_report without test_hash - check fingerprint timestamp as fallback
+                    fingerprint = read_fingerprint(basename, language)
+                    if fingerprint:
+                        # If fingerprint is newer than run_report, run_report might be stale
+                        from datetime import datetime
+                        try:
+                            fp_time = datetime.fromisoformat(fingerprint.timestamp.replace('Z', '+00:00'))
+                            rr_time = datetime.fromisoformat(run_report.timestamp.replace('Z', '+00:00'))
+                            if fp_time > rr_time:
+                                return False  # run_report predates fingerprint, might be stale
+                        except (ValueError, AttributeError):
+                            pass  # If timestamps can't be parsed, skip this check
+
+        # Check verify has been done (unless skip_verify)
+        # Without this, workflow would be "complete" after crash even though verify hasn't run
+        # Bug #23 fix: Also check for 'skip:' prefix which indicates operation was skipped, not executed
+        if not skip_verify:
+            fingerprint = read_fingerprint(basename, language)
+            if fingerprint:
+                # If command starts with 'skip:', the operation was skipped, not completed
+                if fingerprint.command.startswith('skip:'):
+                    return False
+                if fingerprint.command not in ['verify', 'test', 'fix', 'update']:
+                    return False
+
+        # CRITICAL FIX: Check tests have been run (unless skip_tests)
+        # Without this, workflow would be "complete" after verify even though tests haven't run
+        # This prevents false positive success when skip_verify=True but tests are still required
+        # Bug #23 fix: Also check for 'skip:' prefix which indicates operation was skipped, not executed
+        if not skip_tests:
+            fp = read_fingerprint(basename, language)
+            if fp:
+                # If command starts with 'skip:', the operation was skipped, not completed
+                if fp.command.startswith('skip:'):
+                    return False
+                if fp.command not in ['test', 'fix', 'update']:
+                    return False
+
+    return True
 
 
 def check_for_dependencies(prompt_content: str) -> bool:
@@ -670,7 +1170,7 @@ def _check_example_success_history(basename: str, language: str) -> bool:
     
     # Strategy 2b: Look for historical run reports with exit_code == 0
     # Check all run report files in the meta directory that match the pattern
-    run_report_pattern = f"{basename}_{language}_run"
+    run_report_pattern = f"{_safe_basename(basename)}_{language}_run"
     for file in meta_dir.glob(f"{run_report_pattern}*.json"):
         try:
             with open(file, 'r') as f:
@@ -693,7 +1193,7 @@ def _check_example_success_history(basename: str, language: str) -> bool:
     return False
 
 
-def sync_determine_operation(basename: str, language: str, target_coverage: float, budget: float = 10.0, log_mode: bool = False, prompts_dir: str = "prompts", skip_tests: bool = False, skip_verify: bool = False) -> SyncDecision:
+def sync_determine_operation(basename: str, language: str, target_coverage: float, budget: float = 10.0, log_mode: bool = False, prompts_dir: str = "prompts", skip_tests: bool = False, skip_verify: bool = False, context_override: Optional[str] = None) -> SyncDecision:
     """
     Core decision-making function for sync operations with skip flag awareness.
     
@@ -713,14 +1213,14 @@ def sync_determine_operation(basename: str, language: str, target_coverage: floa
     
     if log_mode:
         # Skip locking for read-only analysis
-        return _perform_sync_analysis(basename, language, target_coverage, budget, prompts_dir, skip_tests, skip_verify)
+        return _perform_sync_analysis(basename, language, target_coverage, budget, prompts_dir, skip_tests, skip_verify, context_override)
     else:
         # Normal exclusive locking for actual operations
         with SyncLock(basename, language) as lock:
-            return _perform_sync_analysis(basename, language, target_coverage, budget, prompts_dir, skip_tests, skip_verify)
+            return _perform_sync_analysis(basename, language, target_coverage, budget, prompts_dir, skip_tests, skip_verify, context_override)
 
 
-def _perform_sync_analysis(basename: str, language: str, target_coverage: float, budget: float, prompts_dir: str = "prompts", skip_tests: bool = False, skip_verify: bool = False) -> SyncDecision:
+def _perform_sync_analysis(basename: str, language: str, target_coverage: float, budget: float, prompts_dir: str = "prompts", skip_tests: bool = False, skip_verify: bool = False, context_override: Optional[str] = None) -> SyncDecision:
     """
     Perform the sync state analysis without locking concerns.
     
@@ -749,26 +1249,69 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
     
     # Read fingerprint early since we need it for crash verification
     fingerprint = read_fingerprint(basename, language)
-    
+
+    # Check if auto-deps just completed - ALWAYS regenerate code after auto-deps
+    # This must be checked early, before any run_report processing, because:
+    # 1. Old run_report (if exists) is stale and should be ignored
+    # 2. auto-deps updates dependencies but doesn't regenerate code
+    if fingerprint and fingerprint.command == 'auto-deps':
+        paths = get_pdd_file_paths(basename, language, prompts_dir, context_override=context_override)
+        return SyncDecision(
+            operation='generate',
+            reason='Auto-deps completed - regenerate code with updated prompt',
+            confidence=0.90,
+            estimated_cost=estimate_operation_cost('generate'),
+            details={
+                'decision_type': 'heuristic',
+                'previous_command': 'auto-deps',
+                'code_exists': paths['code'].exists() if paths.get('code') else False,
+                'regenerate_after_autodeps': True
+            }
+        )
+
     run_report = read_run_report(basename, language)
-    if run_report:
-        # Check test failures first (higher priority than exit code)
-        if run_report.tests_failed > 0:
-            return SyncDecision(
-                operation='fix',
-                reason=f'Test failures detected: {run_report.tests_failed} failed tests',
-                confidence=0.90,
-                estimated_cost=estimate_operation_cost('fix'),
-                details={
-                    'decision_type': 'heuristic',
-                    'tests_failed': run_report.tests_failed,
-                    'exit_code': run_report.exit_code,
-                    'coverage': run_report.coverage
-                }
-            )
-        
-        # Check if we just completed a crash operation and need verification
+    # Only process runtime signals (crash/fix/test) if we have a fingerprint
+    # Without a fingerprint, run_report is stale/orphaned and should be ignored
+    if run_report and fingerprint:
+        # Check for prompt changes FIRST - prompt changes take priority over runtime signals
+        # If the user modified the prompt, we need to regenerate regardless of runtime state
+        if fingerprint:
+            paths = get_pdd_file_paths(basename, language, prompts_dir, context_override=context_override)
+            current_prompt_hash = calculate_sha256(paths['prompt'])
+            if current_prompt_hash and current_prompt_hash != fingerprint.prompt_hash:
+                prompt_content = paths['prompt'].read_text(encoding='utf-8', errors='ignore') if paths['prompt'].exists() else ""
+                has_deps = check_for_dependencies(prompt_content)
+                return SyncDecision(
+                    operation='auto-deps' if has_deps else 'generate',
+                    reason='Prompt changed - regenerating (takes priority over runtime signals)',
+                    confidence=0.95,
+                    estimated_cost=estimate_operation_cost('generate'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'prompt_changed': True,
+                        'previous_command': fingerprint.command,
+                        'runtime_state_ignored': True
+                    }
+                )
+
+        # Check if we just completed a crash operation and need verification FIRST
+        # This takes priority over test failures because we need to verify the crash fix worked
+        # BUT only proceed to verify if exit_code == 0 (crash fix succeeded)
         if fingerprint and fingerprint.command == 'crash' and not skip_verify:
+            if run_report.exit_code != 0:
+                # Crash fix didn't work - need to re-run crash
+                return SyncDecision(
+                    operation='crash',
+                    reason=f'Previous crash operation failed (exit_code={run_report.exit_code}) - retry crash fix',
+                    confidence=0.90,
+                    estimated_cost=estimate_operation_cost('crash'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'previous_command': 'crash',
+                        'exit_code': run_report.exit_code,
+                        'workflow_stage': 'crash_retry'
+                    }
+                )
             return SyncDecision(
                 operation='verify',
                 reason='Previous crash operation completed - verify example runs correctly',
@@ -782,6 +1325,41 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
                 }
             )
         
+        # Check test failures (after crash verification check)
+        if run_report.tests_failed > 0:
+            # First check if the test file actually exists
+            pdd_files = get_pdd_file_paths(basename, language, prompts_dir, context_override=context_override)
+            test_file = pdd_files.get('test')
+            
+            # Only suggest 'fix' if test file exists
+            if test_file and test_file.exists():
+                return SyncDecision(
+                    operation='fix',
+                    reason=f'Test failures detected: {run_report.tests_failed} failed tests',
+                    confidence=0.90,
+                    estimated_cost=estimate_operation_cost('fix'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'tests_failed': run_report.tests_failed,
+                        'exit_code': run_report.exit_code,
+                        'coverage': run_report.coverage
+                    }
+                )
+            # If test file doesn't exist but we have test failures in run report,
+            # we need to generate the test first
+            else:
+                return SyncDecision(
+                    operation='test',
+                    reason='Test failures reported but test file missing - need to generate tests',
+                    confidence=0.85,
+                    estimated_cost=estimate_operation_cost('test'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'run_report_shows_failures': True,
+                        'test_file_exists': False
+                    }
+                )
+        
         # Then check for runtime crashes (only if no test failures)
         if run_report.exit_code != 0:
             # Context-aware decision: prefer 'fix' over 'crash' when example has run successfully before
@@ -833,6 +1411,23 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
                         'skip_tests': True
                     }
                 )
+            elif run_report.tests_failed == 0 and run_report.tests_passed > 0:
+                # Tests pass but coverage is below target
+                # Return 'test_extend' to signal we need to ADD more tests, not regenerate
+                return SyncDecision(
+                    operation='test_extend',
+                    reason=f'Tests pass ({run_report.tests_passed} passed) but coverage {run_report.coverage:.1f}% below target {target_coverage:.1f}% - extending tests',
+                    confidence=0.85,
+                    estimated_cost=estimate_operation_cost('test'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'current_coverage': run_report.coverage,
+                        'target_coverage': target_coverage,
+                        'tests_passed': run_report.tests_passed,
+                        'tests_failed': run_report.tests_failed,
+                        'extend_tests': True
+                    }
+                )
             else:
                 return SyncDecision(
                     operation='test',
@@ -849,7 +1444,7 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
                 )
     
     # 2. Analyze File State
-    paths = get_pdd_file_paths(basename, language, prompts_dir)
+    paths = get_pdd_file_paths(basename, language, prompts_dir, context_override=context_override)
     current_hashes = calculate_current_hashes(paths)
     
     # 3. Implement the Decision Tree
@@ -926,7 +1521,7 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
     
     if not changes:
         # No Changes (Hashes Match Fingerprint) - Progress workflow with skip awareness
-        if _is_workflow_complete(paths, skip_tests, skip_verify):
+        if _is_workflow_complete(paths, skip_tests, skip_verify, basename, language):
             return SyncDecision(
                 operation='nothing',
                 reason=f'All required files synchronized (skip_tests={skip_tests}, skip_verify={skip_verify})',
@@ -939,7 +1534,63 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
                     'workflow_complete': True
                 }
             )
-        
+
+        # Handle incomplete workflow when all files exist (including test)
+        # This addresses the blind spot where crash/verify/test logic only runs when test is missing
+        if (paths['code'].exists() and paths['example'].exists() and paths['test'].exists()):
+            run_report = read_run_report(basename, language)
+
+            # BUG 4 & 1: No run_report OR crash detected (exit_code != 0)
+            if not run_report or run_report.exit_code != 0:
+                return SyncDecision(
+                    operation='crash',
+                    reason='All files exist but needs validation' +
+                           (' - no run_report' if not run_report else f' - exit_code={run_report.exit_code}'),
+                    confidence=0.85,
+                    estimated_cost=estimate_operation_cost('crash'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'all_files_exist': True,
+                        'run_report_missing': not run_report,
+                        'exit_code': None if not run_report else run_report.exit_code,
+                        'workflow_stage': 'post_regeneration_validation'
+                    }
+                )
+
+            # BUG 2: Verify not run yet (run_report exists, exit_code=0, but command != verify/test)
+            if fingerprint and fingerprint.command not in ['verify', 'test', 'fix', 'update'] and not skip_verify:
+                return SyncDecision(
+                    operation='verify',
+                    reason='All files exist but verification not completed',
+                    confidence=0.85,
+                    estimated_cost=estimate_operation_cost('verify'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'all_files_exist': True,
+                        'last_command': fingerprint.command,
+                        'workflow_stage': 'verification_pending'
+                    }
+                )
+
+            # Stale run_report detected: _is_workflow_complete returned False but all other conditions passed
+            # This happens when run_report.test_hash doesn't match current test file, or
+            # when fingerprint timestamp > run_report timestamp (legacy detection)
+            # Need to re-run tests to get accurate results
+            if run_report and run_report.exit_code == 0:
+                return SyncDecision(
+                    operation='test',
+                    reason='Run report is stale - need to re-run tests to verify current state',
+                    confidence=0.9,
+                    estimated_cost=estimate_operation_cost('test'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'all_files_exist': True,
+                        'run_report_stale': True,
+                        'run_report_test_hash': run_report.test_hash,
+                        'workflow_stage': 'revalidation'
+                    }
+                )
+
         # Progress workflow considering skip flags
         if paths['code'].exists() and not paths['example'].exists():
             return SyncDecision(
@@ -960,8 +1611,9 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
             
             # Check if example has been crash-tested and verified before allowing test generation
             run_report = read_run_report(basename, language)
-            if not run_report:
+            if not run_report and not skip_verify:
                 # No run report exists - need to test the example first
+                # But if skip_verify is True, skip crash/verify and go to test generation
                 return SyncDecision(
                     operation='crash',
                     reason='Example exists but needs runtime testing before test generation',
@@ -975,8 +1627,9 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
                         'workflow_stage': 'crash_validation'
                     }
                 )
-            elif run_report.exit_code != 0:
+            elif run_report and run_report.exit_code != 0 and not skip_verify:
                 # Example crashed - fix it before proceeding
+                # But if skip_verify is True, skip crash fix and proceed
                 return SyncDecision(
                     operation='crash',
                     reason='Example crashes - fix runtime errors before test generation',
@@ -1023,6 +1676,22 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
         # Some files are missing but no changes detected
         if not paths['code'].exists():
             if paths['prompt'].exists():
+                # CRITICAL FIX: Check if auto-deps was just completed to prevent infinite loop
+                if fingerprint and fingerprint.command == 'auto-deps':
+                    return SyncDecision(
+                        operation='generate',
+                        reason='Auto-deps completed, now generate missing code file',
+                        confidence=0.90,
+                        estimated_cost=estimate_operation_cost('generate'),
+                        details={
+                            'decision_type': 'heuristic',
+                            'prompt_path': str(paths['prompt']),
+                            'code_exists': False,
+                            'auto_deps_completed': True,
+                            'previous_command': fingerprint.command
+                        }
+                    )
+                
                 prompt_content = paths['prompt'].read_text(encoding='utf-8', errors='ignore')
                 if check_for_dependencies(prompt_content):
                     return SyncDecision(
@@ -1124,18 +1793,69 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
             )
     
     else:
-        # Complex Changes (Multiple Files Modified / Conflicts)
-        return SyncDecision(
-            operation='analyze_conflict',
-            reason='Multiple files changed - requires conflict analysis',
-            confidence=0.70,
-            estimated_cost=estimate_operation_cost('analyze_conflict'),
-            details={
-                'decision_type': 'heuristic',
-                'changed_files': changes,
-                'num_changes': len(changes)
-            }
-        )
+        # Complex Changes (Multiple Files Modified)
+        # CRITICAL: Only treat as conflict if prompt changed along with derived artifacts
+        # If only derived artifacts changed (code, example, test), this is NOT a conflict
+        # per PDD doctrine - all are derived from the unchanged prompt
+
+        if 'prompt' in changes:
+            # True conflict: prompt (source of truth) changed along with derived artifacts
+            return SyncDecision(
+                operation='analyze_conflict',
+                reason='Prompt and derived files changed - requires conflict analysis',
+                confidence=0.70,
+                estimated_cost=estimate_operation_cost('analyze_conflict'),
+                details={
+                    'decision_type': 'heuristic',
+                    'changed_files': changes,
+                    'num_changes': len(changes),
+                    'prompt_changed': True
+                }
+            )
+        else:
+            # Only derived artifacts changed - prompt (source of truth) is unchanged
+            # Continue workflow from where it was interrupted
+
+            # If code changed, need to re-verify
+            if 'code' in changes:
+                return SyncDecision(
+                    operation='verify',
+                    reason='Derived files changed (prompt unchanged) - verify code works',
+                    confidence=0.85,
+                    estimated_cost=estimate_operation_cost('verify'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'changed_files': changes,
+                        'num_changes': len(changes),
+                        'prompt_changed': False,
+                        'workflow_stage': 'continue_after_interruption'
+                    }
+                )
+            # If only example/test changed
+            elif 'example' in changes:
+                return SyncDecision(
+                    operation='verify',
+                    reason='Example changed (prompt unchanged) - verify example runs',
+                    confidence=0.85,
+                    estimated_cost=estimate_operation_cost('verify'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'changed_files': changes,
+                        'prompt_changed': False
+                    }
+                )
+            elif 'test' in changes:
+                return SyncDecision(
+                    operation='test',
+                    reason='Test changed (prompt unchanged) - run tests',
+                    confidence=0.85,
+                    estimated_cost=estimate_operation_cost('test'),
+                    details={
+                        'decision_type': 'heuristic',
+                        'changed_files': changes,
+                        'prompt_changed': False
+                    }
+                )
     
     # Fallback - should not reach here normally
     return SyncDecision(
@@ -1152,7 +1872,14 @@ def _perform_sync_analysis(basename: str, language: str, target_coverage: float,
     )
 
 
-def analyze_conflict_with_llm(basename: str, language: str, fingerprint: Fingerprint, changed_files: List[str], prompts_dir: str = "prompts") -> SyncDecision:
+def analyze_conflict_with_llm(
+    basename: str,
+    language: str,
+    fingerprint: Fingerprint,
+    changed_files: List[str],
+    prompts_dir: str = "prompts",
+    context_override: Optional[str] = None,
+) -> SyncDecision:
     """
     Resolve complex sync conflicts using an LLM.
     
@@ -1185,7 +1912,7 @@ def analyze_conflict_with_llm(basename: str, language: str, fingerprint: Fingerp
             )
         
         # 2. Gather file paths and diffs
-        paths = get_pdd_file_paths(basename, language, prompts_dir)
+        paths = get_pdd_file_paths(basename, language, prompts_dir, context_override=context_override)
         
         # Generate diffs for changed files
         diffs = {}