pdd-cli 0.0.41__py3-none-any.whl → 0.0.42__py3-none-any.whl

pdd/sync_determine_operation.py

@@ -1,574 +1,1039 @@
-# pdd/sync_determine_operation.py
+"""
+sync_determine_operation.py
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Core decision-making logic for the `pdd sync` command.
+Implements fingerprint-based state analysis and deterministic operation selection.
+"""
 
 import os
 import sys
 import json
 import hashlib
 import subprocess
-import threading
-from dataclasses import dataclass, asdict, field
-from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional, Dict, Any, List
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+import psutil
 
-# --- Dependencies ---
-# This implementation requires the 'psutil' library for robust PID checking.
-# It can be installed with: pip install psutil
+# Platform-specific imports for file locking
 try:
-    import psutil
+    import fcntl
+    HAS_FCNTL = True
 except ImportError:
-    print("Error: 'psutil' library not found. Please install it using 'pip install psutil'", file=sys.stderr)
-    sys.exit(1)
+    HAS_FCNTL = False
 
-# Platform-specific locking
-if sys.platform == 'win32':
+try:
     import msvcrt
-else:
-    import fcntl
+    HAS_MSVCRT = True
+except ImportError:
+    HAS_MSVCRT = False
+
+# Import PDD internal modules
+from pdd.construct_paths import 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
+
+# Constants - Use functions for dynamic path resolution
+def get_pdd_dir():
+    """Get the .pdd directory relative to current working directory."""
+    return Path.cwd() / '.pdd'
 
-# --- Constants for Directory Structure ---
-PDD_DIR = Path(".pdd")
-META_DIR = PDD_DIR / "meta"
-LOCKS_DIR = PDD_DIR / "locks"
+def get_meta_dir():
+    """Get the metadata directory."""
+    return get_pdd_dir() / 'meta'
 
-PROMPTS_ROOT_DIR = Path("prompts")
-CODE_ROOT_DIR = Path("src")
-EXAMPLES_ROOT_DIR = Path("examples")
-TESTS_ROOT_DIR = Path("tests")
+def get_locks_dir():
+    """Get the locks directory."""
+    return get_pdd_dir() / 'locks'
 
+# For backward compatibility
+PDD_DIR = get_pdd_dir()
+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', 
+           'sync_determine_operation', 'analyze_conflict_with_llm']
 
-# --- Data Structures ---
 
 @dataclass
 class Fingerprint:
     """Represents the last known good state of a PDD unit."""
     pdd_version: str
     timestamp: str  # ISO 8601 format
-    command: str
-    prompt_hash: Optional[str] = None
-    code_hash: Optional[str] = None
-    example_hash: Optional[str] = None
-    test_hash: Optional[str] = None
+    command: str    # e.g., "generate", "fix"
+    prompt_hash: Optional[str]
+    code_hash: Optional[str]
+    example_hash: Optional[str]
+    test_hash: Optional[str]
+
 
 @dataclass
 class RunReport:
-    """Represents the results of the last test or execution run."""
+    """Represents the results from the last test run."""
     timestamp: str
     exit_code: int
     tests_passed: int
     tests_failed: int
     coverage: float
 
-@dataclass
-class LLMConflictResolutionOutput:
-    """Represents the structured output from the LLM for conflict resolution."""
-    next_operation: str
-    reason: str
-    confidence: float
 
 @dataclass
 class SyncDecision:
-    """Represents the recommended operation to run next."""
-    operation: str
+    """Represents a decision about what PDD operation to run next."""
+    operation: str  # 'auto-deps', 'generate', 'example', 'crash', 'verify', 'test', 'fix', 'update', 'analyze_conflict', 'nothing'
     reason: str
     details: Dict[str, Any] = field(default_factory=dict)
+    estimated_cost: float = 0.0
+    confidence: float = 1.0
+    prerequisites: List[str] = field(default_factory=list)
 
-# --- Mock Internal PDD Modules ---
-# These are placeholders for the internal pdd library functions.
-
-def load_prompt_template(prompt_name: str) -> Optional[str]:
-    """
-    (MOCK) Loads a prompt template from the pdd library.
-    In a real scenario, this would load from a package resource.
-    """
-    templates = {
-        "sync_analysis_LLM.prompt": """
-You are an expert software development assistant. Your task is to resolve a synchronization conflict in a PDD unit.
-Both the user and the PDD tool have made changes, and you must decide the best course of action.
-
-Analyze the following information:
-
-**Last Known Good State (Fingerprint):**
-```json
-{fingerprint}
-```
-
-**Files Changed Since Last Sync:**
-- {changed_files_list}
-
-**Diffs:**
-
---- PROMPT DIFF ---
-{prompt_diff}
---- END PROMPT DIFF ---
-
---- CODE DIFF ---
-{code_diff}
---- END CODE DIFF ---
-
---- TEST DIFF ---
-{test_diff}
---- END TEST DIFF ---
-
---- EXAMPLE DIFF ---
-{example_diff}
---- END EXAMPLE DIFF ---
-
-Based on the diffs, determine the user's intent and the nature of the conflict.
-Respond with a JSON object recommending the next operation. The possible operations are:
-- "generate": The prompt changes are significant; regenerate the code.
-- "update": The code changes are valuable; update the prompt to reflect them.
-- "fix": The test changes seem to be fixing a bug; try to fix the code.
-- "merge_manually": The conflict is too complex. Ask the user to merge changes.
-
-Your JSON response must have the following format:
-{{
-  "next_operation": "your_recommendation",
-  "reason": "A clear, concise explanation of why you chose this operation.",
-  "confidence": 0.9
-}}
-"""
-    }
-    return templates.get(prompt_name)
-
-def llm_invoke(prompt: str, **kwargs) -> Dict[str, Any]:
-    """
-    (MOCK) Invokes the LLM with a given prompt.
-    This mock version provides a deterministic response for demonstration.
-    """
-    print("--- (MOCK) LLM Invocation ---")
-    print(f"Prompt sent to LLM:\n{prompt[:500]}...")
-    # In a real scenario, this would call an actual LLM API.
-    # Here, we return a canned response with low confidence to test the failure path.
-    response_obj = LLMConflictResolutionOutput(
-        next_operation="update",
-        reason="Mock LLM analysis determined that the manual code changes are significant but confidence is low.",
-        confidence=0.70
-    )
-    return {
-        "result": response_obj,
-        "cost": 0.001,
-        "model_name": "mock-gpt-4"
-    }
-
-
-# --- Directory and Locking Mechanism ---
-
-def _ensure_pdd_dirs_exist():
-    """Ensures that the .pdd metadata and lock directories exist."""
-    META_DIR.mkdir(parents=True, exist_ok=True)
-    LOCKS_DIR.mkdir(parents=True, exist_ok=True)
-
-_lock_registry = threading.local()
 
 class SyncLock:
-    """
-    A robust, re-entrant, PID-aware file lock for synchronizing operations.
-    Ensures only one process can operate on a PDD unit at a time.
-    """
+    """Context manager for handling file-descriptor based locking."""
+    
     def __init__(self, basename: str, language: str):
-        _ensure_pdd_dirs_exist()  # Ensure directories exist before creating lock file
-        self.lock_dir = LOCKS_DIR
-        self.lock_path = self.lock_dir / f"{basename}_{language}.lock"
-        self._lock_fd = None
-        self._is_reentrant_acquisition = False
-        self.lock_key = str(self.lock_path)
-        # The file descriptor is only stored on the instance that actually acquires the lock
-        self._is_lock_owner = False
-
-    @property
-    def lock_file_path(self):
-        return self.lock_path
-
-    def _get_lock_count(self) -> int:
-        if not hasattr(_lock_registry, 'counts'):
-            _lock_registry.counts = {}
-        return _lock_registry.counts.get(self.lock_key, 0)
-
-    def _increment_lock_count(self):
-        if not hasattr(_lock_registry, 'counts'):
-            _lock_registry.counts = {}
-        count = _lock_registry.counts.get(self.lock_key, 0)
-        _lock_registry.counts[self.lock_key] = count + 1
-
-    def _decrement_lock_count(self) -> int:
-        if not hasattr(_lock_registry, 'counts'):
-            _lock_registry.counts = {}
-        count = _lock_registry.counts.get(self.lock_key, 0)
-        if count > 0:
-            _lock_registry.counts[self.lock_key] = count - 1
-        return _lock_registry.counts.get(self.lock_key, 0)
-
-    def acquire(self):
-        """
-        Acquires an exclusive lock, handling stale locks from crashed processes.
-        Raises TimeoutError if the lock is held by another active process.
-        """
-        lock_count = self._get_lock_count()
-        if lock_count > 0:  # Re-entrancy
-            self._is_reentrant_acquisition = True
-            self._increment_lock_count()
-            return
-
-        # First time acquiring in this thread. Perform the actual lock.
-        if self.lock_path.exists():
-            try:
-                pid_str = self.lock_path.read_text().strip()
-                if pid_str:
-                    pid = int(pid_str)
-                    if psutil.pid_exists(pid):
-                        raise TimeoutError(f"is locked by another process (PID: {pid})")
-                    else:
-                        self.lock_path.unlink()
-            except (ValueError, FileNotFoundError):
-                # Corrupted or unreadable lock file, treat as stale
-                self.lock_path.unlink(missing_ok=True)
-
-        # Use O_TRUNC to ensure we overwrite any previous (e.g., corrupted) content
-        self._lock_fd = os.open(self.lock_path, os.O_CREAT | os.O_WRONLY | os.O_TRUNC)
-        self._is_lock_owner = True
-
-        try:
-            if sys.platform == 'win32':
-                msvcrt.locking(self._lock_fd, msvcrt.LK_NBLCK, 1)
-            else:
-                fcntl.flock(self._lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-        except (IOError, BlockingIOError):
-            os.close(self._lock_fd)
-            self._lock_fd = None
-            self._is_lock_owner = False
-            raise TimeoutError("Failed to acquire lock; another process may have just started.")
-
-        os.write(self._lock_fd, str(os.getpid()).encode())
-        os.fsync(self._lock_fd)
-        self._increment_lock_count()
-
-    def release(self):
-        """Releases the lock and cleans up the lock file."""
-        new_count = self._decrement_lock_count()
-        
-        if new_count == 0 and self._is_lock_owner:
-            # This was the last lock holder in this thread, so release the file lock.
-            if self._lock_fd:
-                if sys.platform != 'win32':
-                     fcntl.flock(self._lock_fd, fcntl.LOCK_UN)
-                os.close(self._lock_fd)
-                self._lock_fd = None
-            
-            try:
-                if self.lock_path.exists():
-                    # Safety check: only delete if we are still the owner
-                    pid_str = self.lock_path.read_text().strip()
-                    if not pid_str or int(pid_str) == os.getpid():
-                        self.lock_path.unlink()
-            except (OSError, ValueError, FileNotFoundError):
-                pass # Ignore errors on cleanup
-
+        self.basename = basename
+        self.language = language
+        self.lock_file = get_locks_dir() / f"{basename}_{language}.lock"
+        self.fd = None
+        self.current_pid = os.getpid()
+    
     def __enter__(self):
         self.acquire()
         return self
-
+    
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.release()
+    
+    def acquire(self):
+        """Acquire the lock, handling stale locks and re-entrancy."""
+        # Ensure lock directory exists
+        self.lock_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            # Check if lock file exists
+            if self.lock_file.exists():
+                try:
+                    # Read PID from lock file
+                    stored_pid = int(self.lock_file.read_text().strip())
+                    
+                    # Check if this is the same process (re-entrancy)
+                    if stored_pid == self.current_pid:
+                        return
+                    
+                    # Check if the process is still running
+                    if psutil.pid_exists(stored_pid):
+                        raise TimeoutError(f"Lock held by running process {stored_pid}")
+                    
+                    # Stale lock - remove it
+                    self.lock_file.unlink(missing_ok=True)
+                    
+                except (ValueError, FileNotFoundError):
+                    # Invalid lock file - remove it
+                    self.lock_file.unlink(missing_ok=True)
+            
+            # Create lock file and acquire file descriptor lock
+            self.lock_file.touch()
+            self.fd = open(self.lock_file, 'w')
+            
+            if HAS_FCNTL:
+                # POSIX systems
+                fcntl.flock(self.fd.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+            elif HAS_MSVCRT:
+                # Windows systems
+                msvcrt.locking(self.fd.fileno(), msvcrt.LK_NBLCK, 1)
+            
+            # Write current PID to lock file
+            self.fd.write(str(self.current_pid))
+            self.fd.flush()
+            
+        except (IOError, OSError) as e:
+            if self.fd:
+                self.fd.close()
+                self.fd = None
+            raise TimeoutError(f"Failed to acquire lock: {e}")
+    
+    def release(self):
+        """Release the lock and clean up."""
+        if self.fd:
+            try:
+                if HAS_FCNTL:
+                    fcntl.flock(self.fd.fileno(), fcntl.LOCK_UN)
+                elif HAS_MSVCRT:
+                    msvcrt.locking(self.fd.fileno(), msvcrt.LK_UNLCK, 1)
+                
+                self.fd.close()
+                self.fd = None
+                
+                # Remove lock file
+                self.lock_file.unlink(missing_ok=True)
+                
+            except (IOError, OSError):
+                # Best effort cleanup
+                pass
+
+
+def get_extension(language: str) -> str:
+    """Get file extension for a programming language."""
+    extensions = {
+        'python': 'py',
+        'javascript': 'js', 
+        'typescript': 'ts',
+        'java': 'java',
+        'cpp': 'cpp',
+        'c': 'c',
+        'ruby': 'rb',
+        'go': 'go',
+        'rust': 'rs',
+        'php': 'php',
+        'swift': 'swift',
+        'kotlin': 'kt',
+        'scala': 'scala',
+        'csharp': 'cs',
+        'css': 'css',
+        'html': 'html',
+        'sql': 'sql',
+        'shell': 'sh',
+        'bash': 'sh',
+        'powershell': 'ps1',
+        'r': 'r',
+        'matlab': 'm',
+        'lua': 'lua',
+        'perl': 'pl',
+    }
+    return extensions.get(language.lower(), language.lower())
 
 
-# --- State Analysis Functions ---
-
-LANGUAGE_EXTENSIONS = {
-    "python": "py",
-    "javascript": "js",
-    "typescript": "ts",
-    "rust": "rs",
-    "go": "go",
-}
-
-def get_language_extension(language: str) -> str:
-    """Gets the file extension for a given language."""
-    if language not in LANGUAGE_EXTENSIONS:
-        raise ValueError(f"Unsupported language: {language}")
-    return LANGUAGE_EXTENSIONS[language]
+def get_pdd_file_paths(basename: str, language: str, prompts_dir: str = "prompts") -> Dict[str, Path]:
+    """Returns a dictionary mapping file types to their expected Path objects."""
+    try:
+        # Use construct_paths to get configuration-aware paths
+        prompt_filename = f"{basename}_{language}.prompt"
+        prompt_path = str(Path(prompts_dir) / prompt_filename)
+        
+        # Check if prompt file exists - if not, we can't proceed with construct_paths
+        if not Path(prompt_path).exists():
+            # Fall back to default path construction if 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}")
+            }
+        
+        input_file_paths = {
+            "prompt_file": prompt_path
+        }
+        
+        # Only call construct_paths if the prompt file exists
+        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={}
+        )
+        
+        # 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', ''))
+        if not code_path:
+            # Fallback to constructing from basename
+            extension = get_extension(language)
+            code_path = f"{basename}.{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
+        # where code file doesn't exist yet (during initial sync startup)
+        try:
+            # Create a temporary empty code file if it doesn't exist for path resolution
+            code_path_obj = Path(code_path)
+            temp_code_created = False
+            if not code_path_obj.exists():
+                code_path_obj.parent.mkdir(parents=True, exist_ok=True)
+                code_path_obj.touch()
+                temp_code_created = True
+            
+            try:
+                # Get example path using example command
+                _, _, 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={}
+                )
+                test_path = Path(test_output_paths.get('output', f"test_{basename}.{get_extension(language)}"))
+                
+            finally:
+                # Clean up temporary file if we created it
+                if temp_code_created and code_path_obj.exists() and code_path_obj.stat().st_size == 0:
+                    code_path_obj.unlink()
+            
+        except Exception as e:
+            # Log the specific exception that's causing fallback to wrong paths
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.warning(f"construct_paths failed in get_pdd_file_paths: {type(e).__name__}: {e}")
+            logger.warning(f"Falling back to .pddrc-aware path construction")
+            logger.warning(f"prompt_path: {prompt_path}, code_path: {code_path}")
+            
+            # 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
+                _, _, example_output_paths, _ = construct_paths(
+                    input_file_paths={"prompt_file": prompt_path},
+                    force=True, quiet=True, command="example", command_options={}
+                )
+                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)}"))
+                
+            except Exception:
+                # Final fallback to deriving from code path if all else fails
+                code_path_obj = Path(code_path)
+                code_dir = code_path_obj.parent
+                code_stem = code_path_obj.stem
+                code_ext = code_path_obj.suffix
+                example_path = code_dir / f"{code_stem}_example{code_ext}"
+                test_path = code_dir / f"test_{code_stem}{code_ext}"
+        
+        return {
+            'prompt': Path(prompt_path),
+            'code': Path(code_path),
+            'example': example_path,
+            'test': test_path
+        }
+        
+    except Exception as e:
+        # Fallback to simple naming if construct_paths fails
+        extension = get_extension(language)
+        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}")
+        }
 
-def get_pdd_file_paths(basename: str, language: str) -> Dict[str, Path]:
-    """Returns a dictionary mapping file types to their expected paths."""
-    ext = get_language_extension(language)
-    return {
-        'prompt': PROMPTS_ROOT_DIR / f"{basename}_{language}.prompt",
-        'code': CODE_ROOT_DIR / f"{basename}.{ext}",
-        'example': EXAMPLES_ROOT_DIR / f"{basename}_example.{ext}",
-        'test': TESTS_ROOT_DIR / f"test_{basename}.{ext}",
-    }
 
 def calculate_sha256(file_path: Path) -> Optional[str]:
-    """Calculates the SHA256 hash of a file if it exists, otherwise returns None."""
-    if not file_path.is_file():
+    """Calculates the SHA256 hash of a file if it exists."""
+    if not file_path.exists():
         return None
     
-    sha256_hash = hashlib.sha256()
-    with open(file_path, "rb") as f:
-        for byte_block in iter(lambda: f.read(4096), b""):
-            sha256_hash.update(byte_block)
-    return sha256_hash.hexdigest()
+    try:
+        hasher = hashlib.sha256()
+        with open(file_path, 'rb') as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                hasher.update(chunk)
+        return hasher.hexdigest()
+    except (IOError, OSError):
+        return None
+
 
-def _read_json_file(file_path: Path, data_class) -> Optional[Any]:
-    """Generic JSON file reader and validator."""
-    if not file_path.is_file():
+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"
+    
+    if not fingerprint_file.exists():
         return None
+    
     try:
-        with open(file_path, 'r') as f:
+        with open(fingerprint_file, 'r') as f:
             data = json.load(f)
-            return data_class(**data)
-    except (json.JSONDecodeError, TypeError):
-        # Catches corrupted file, or if data doesn't match dataclass fields
+        
+        return Fingerprint(
+            pdd_version=data['pdd_version'],
+            timestamp=data['timestamp'],
+            command=data['command'],
+            prompt_hash=data.get('prompt_hash'),
+            code_hash=data.get('code_hash'),
+            example_hash=data.get('example_hash'),
+            test_hash=data.get('test_hash')
+        )
+    except (json.JSONDecodeError, KeyError, IOError):
         return None
 
-def read_fingerprint(basename: str, language: str) -> Optional[Fingerprint]:
-    """Reads and validates the JSON fingerprint file."""
-    fingerprint_path = META_DIR / f"{basename}_{language}.json"
-    return _read_json_file(fingerprint_path, Fingerprint)
 
 def read_run_report(basename: str, language: str) -> Optional[RunReport]:
     """Reads and validates the JSON run report file."""
-    report_path = META_DIR / f"{basename}_{language}_run.json"
-    return _read_json_file(report_path, RunReport)
+    meta_dir = get_meta_dir()
+    meta_dir.mkdir(parents=True, exist_ok=True)
+    run_report_file = meta_dir / f"{basename}_{language}_run.json"
+    
+    if not run_report_file.exists():
+        return None
+    
+    try:
+        with open(run_report_file, 'r') as f:
+            data = json.load(f)
+        
+        return RunReport(
+            timestamp=data['timestamp'],
+            exit_code=data['exit_code'],
+            tests_passed=data['tests_passed'],
+            tests_failed=data['tests_failed'],
+            coverage=data['coverage']
+        )
+    except (json.JSONDecodeError, KeyError, IOError):
+        return None
+
 
 def calculate_current_hashes(paths: Dict[str, Path]) -> Dict[str, Optional[str]]:
     """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(path)
-        for file_type, path in paths.items()
+        f"{file_type}_hash": calculate_sha256(file_path)
+        for file_type, file_path in paths.items()
     }
 
-# --- LLM-based Conflict Analysis ---
 
 def get_git_diff(file_path: Path) -> str:
+    """Get git diff for a file against HEAD."""
+    try:
+        result = subprocess.run(
+            ['git', 'diff', 'HEAD', str(file_path)],
+            capture_output=True,
+            text=True,
+            cwd=file_path.parent if file_path.parent.exists() else Path.cwd()
+        )
+        
+        if result.returncode == 0:
+            return result.stdout
+        else:
+            return ""
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return ""
+
+
+def validate_expected_files(fingerprint: Optional[Fingerprint], paths: Dict[str, Path]) -> Dict[str, bool]:
     """
-    Gets the git diff of a file against its last committed version (HEAD).
-    Returns the full content for untracked files.
+    Validate that files expected to exist based on fingerprint actually exist.
+    
+    Args:
+        fingerprint: The last known good state fingerprint
+        paths: Dict mapping file types to their expected Path objects
+    
+    Returns:
+        Dict mapping file types to existence status
     """
-    if not file_path.exists():
-        return ""
+    validation = {}
     
-    # Try to use a relative path if possible, as git's output is cleaner.
-    # This is safe because test fixtures chdir into the repo root.
-    try:
-        path_for_git = file_path.relative_to(Path.cwd())
-    except ValueError:
-        # Not relative to CWD, use the original absolute path.
-        path_for_git = file_path
-
-    # Use 'git status' to check if the file is tracked
-    try:
-        status_result = subprocess.run(
-            ['git', 'status', '--porcelain', str(path_for_git)],
-            capture_output=True, text=True, check=True, encoding='utf-8'
-        )
-        is_untracked = status_result.stdout.strip().startswith('??')
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        # Not a git repo, git not found, or file not in repo. Fallback to content.
-        return file_path.read_text(encoding='utf-8')
-
-    command = ['git', 'diff']
-    if is_untracked:
-        # Diff against nothing to show the whole file as an addition
-        # Use /dev/null for POSIX and NUL for Windows
-        null_device = "NUL" if sys.platform == "win32" else "/dev/null"
-        command.extend(['--no-index', null_device, str(path_for_git)])
-    else:
-        # Diff against the last commit
-        command.extend(['HEAD', '--', str(path_for_git)])
+    if not fingerprint:
+        return validation
+    
+    # Check each file type that has a hash in the fingerprint
+    if fingerprint.code_hash:
+        validation['code'] = paths['code'].exists()
+    if fingerprint.example_hash:
+        validation['example'] = paths['example'].exists()
+    if fingerprint.test_hash:
+        validation['test'] = paths['test'].exists()
         
-    try:
-        # The `git diff` command returns exit code 1 if there are differences,
-        # which `check=True` would interpret as an error. We must not use it.
-        diff_result = subprocess.run(
-            command, capture_output=True, text=True, encoding='utf-8'
-        )
-        return diff_result.stdout
-    except FileNotFoundError:
-        # Fallback if git command is not found
-        return file_path.read_text(encoding='utf-8')
-
-def analyze_conflict_with_llm(
-    basename: str,
-    language: str,
+    return validation
+
+
+def _handle_missing_expected_files(
+    missing_files: List[str], 
+    paths: Dict[str, Path], 
     fingerprint: Fingerprint,
-    changed_files: List[str]
+    basename: str, 
+    language: str, 
+    prompts_dir: str,
+    skip_tests: bool = False,
+    skip_verify: bool = False
 ) -> SyncDecision:
     """
-    Uses an LLM to analyze a complex sync conflict and recommend an operation.
+    Handle the case where expected files are missing.
+    Determine the appropriate recovery operation.
+    
+    Args:
+        missing_files: List of file types that are missing
+        paths: Dict mapping file types to their expected Path objects
+        fingerprint: The last known good state fingerprint
+        basename: The base name for the PDD unit
+        language: The programming language
+        prompts_dir: Directory containing prompt files
+        skip_tests: If True, skip test generation
+        skip_verify: If True, skip verification operations
+    
+    Returns:
+        SyncDecision object with the appropriate recovery operation
     """
-    try:
-        prompt_template = load_prompt_template("sync_analysis_LLM.prompt")
-        if not prompt_template:
+    
+    # Priority: regenerate from the earliest missing component
+    if 'code' in missing_files:
+        # Code file missing - start from the beginning
+        if paths['prompt'].exists():
+            prompt_content = paths['prompt'].read_text(encoding='utf-8', errors='ignore')
+            if check_for_dependencies(prompt_content):
+                return SyncDecision(
+                    operation='auto-deps',
+                    reason='Code file missing, prompt has dependencies - regenerate from auto-deps',
+                    details={'missing_files': missing_files, 'prompt_path': str(paths['prompt'])},
+                    estimated_cost=0.5,
+                    confidence=0.85
+                )
+            else:
+                return SyncDecision(
+                    operation='generate',
+                    reason='Code file missing - regenerate from prompt',
+                    details={'missing_files': missing_files, 'prompt_path': str(paths['prompt'])},
+                    estimated_cost=1.0,
+                    confidence=0.90
+                )
+    
+    elif 'example' in missing_files and paths['code'].exists():
+        # Code exists but example missing
+        return SyncDecision(
+            operation='example',
+            reason='Example file missing - regenerate example',
+            details={'missing_files': missing_files, 'code_path': str(paths['code'])},
+            estimated_cost=0.5,
+            confidence=0.85
+        )
+    
+    elif 'test' in missing_files and paths['code'].exists() and paths['example'].exists():
+        # Code and example exist but test missing
+        if skip_tests:
+            # Skip test generation if --skip-tests flag is used
             return SyncDecision(
-                operation="fail_and_request_manual_merge",
-                reason="Failed to load LLM analysis prompt template 'sync_analysis_LLM.prompt'."
+                operation='nothing',
+                reason='Test file missing but --skip-tests specified - workflow complete',
+                details={'missing_files': missing_files, 'skip_tests': True},
+                estimated_cost=0.0,
+                confidence=1.0
             )
-
-        paths = get_pdd_file_paths(basename, language)
-        diffs = {ftype: "" for ftype in ['prompt', 'code', 'test', 'example']}
-        
-        for file_type in changed_files:
-            if file_type in paths:
-                diffs[file_type] = get_git_diff(paths[file_type])
-
-        # Format the prompt for the LLM
-        formatted_prompt = prompt_template.format(
-            fingerprint=json.dumps(asdict(fingerprint), indent=2),
-            changed_files_list=", ".join(changed_files),
-            prompt_diff=diffs['prompt'],
-            code_diff=diffs['code'],
-            test_diff=diffs['test'],
-            example_diff=diffs['example']
-        )
-
-        # Invoke the LLM
-        llm_response = llm_invoke(prompt=formatted_prompt)
-        response_obj = llm_response.get('result')
-
-        # Validate the response object
-        if not isinstance(response_obj, LLMConflictResolutionOutput):
+        else:
             return SyncDecision(
-                operation="fail_and_request_manual_merge",
-                reason=f"LLM did not return the expected Pydantic object. Got type: {type(response_obj).__name__}",
-                details={"raw_response": str(response_obj)}
+                operation='test',
+                reason='Test file missing - regenerate tests',
+                details={'missing_files': missing_files, 'code_path': str(paths['code'])},
+                estimated_cost=1.0,
+                confidence=0.85
             )
+    
+    # Fallback - regenerate everything
+    return SyncDecision(
+        operation='generate',
+        reason='Multiple files missing - regenerate from prompt',
+        details={'missing_files': missing_files},
+        estimated_cost=2.0,
+        confidence=0.80
+    )
 
-        next_op = response_obj.next_operation
-        reason = response_obj.reason
-        confidence = response_obj.confidence
 
-        if confidence < 0.75:
-            return SyncDecision(
-                operation="fail_and_request_manual_merge",
-                reason=f"LLM analysis confidence ({confidence:.2f}) is below threshold. "
-                       f"LLM suggestion was: '{next_op}' - {reason}",
-                details=asdict(response_obj)
-            )
+def _is_workflow_complete(paths: Dict[str, Path], skip_tests: bool = False, skip_verify: bool = False) -> 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
+    
+    Returns:
+        True if all required files exist for the current workflow configuration
+    """
+    required_files = ['code', 'example']
+    
+    if not skip_tests:
+        required_files.append('test')
         
-        return SyncDecision(
-            operation=next_op,
-            reason=f"LLM analysis: {reason}",
-            details=asdict(response_obj)
-        )
+    return all(paths[f].exists() for f in required_files)
 
-    except Exception as e:
-        return SyncDecision(
-            operation="fail_and_request_manual_merge",
-            reason=f"LLM conflict analysis failed: {e}",
-            details={"raw_response": str(locals().get('llm_response', {}).get('result'))}
-        )
 
+def check_for_dependencies(prompt_content: str) -> bool:
+    """Check if prompt contains actual dependency indicators that need auto-deps processing."""
+    # Only check for specific XML tags that indicate actual dependencies
+    xml_dependency_indicators = [
+        '<include>',
+        '<web>',
+        '<shell>'
+    ]
+    
+    # Check for explicit dependency management mentions
+    explicit_dependency_indicators = [
+        'auto-deps',
+        'auto_deps',
+        'dependencies needed',
+        'requires dependencies',
+        'include dependencies'
+    ]
+    
+    prompt_lower = prompt_content.lower()
+    
+    # Check for XML tags (case-sensitive for proper XML)
+    has_xml_deps = any(indicator in prompt_content for indicator in xml_dependency_indicators)
+    
+    # Check for explicit dependency mentions
+    has_explicit_deps = any(indicator in prompt_lower for indicator in explicit_dependency_indicators)
+    
+    return has_xml_deps or has_explicit_deps
 
-# --- Main Decision Function ---
 
-def determine_sync_operation(
-    basename: str,
-    language: str,
-    target_coverage: float = 80.0
-) -> 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) -> SyncDecision:
     """
-    Analyzes a PDD unit's state and determines the next operation.
+    Core decision-making function for sync operations with skip flag awareness.
+    
+    Args:
+        basename: The base name for the PDD unit
+        language: The programming language
+        target_coverage: Desired test coverage percentage
+        budget: Maximum budget for operations
+        log_mode: If True, skip locking entirely for read-only analysis
+        prompts_dir: Directory containing prompt files
+        skip_tests: If True, skip test generation and execution
+        skip_verify: If True, skip verification operations
+    
+    Returns:
+        SyncDecision object with the recommended operation
+    """
+    
+    if log_mode:
+        # Skip locking for read-only analysis
+        return _perform_sync_analysis(basename, language, target_coverage, budget, prompts_dir, skip_tests, skip_verify)
+    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)
 
-    This function is the core of the `pdd sync` command, providing a deterministic,
-    reliable, and safe decision based on runtime signals and file fingerprints.
 
+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:
+    """
+    Perform the sync state analysis without locking concerns.
+    
     Args:
-        basename: The base name of the PDD unit (e.g., 'calculator').
-        language: The programming language of the unit (e.g., 'python').
-        target_coverage: The desired test coverage percentage.
-
+        basename: The base name for the PDD unit
+        language: The programming language
+        target_coverage: Desired test coverage percentage
+        budget: Maximum budget for operations
+        prompts_dir: Directory containing prompt files
+        skip_tests: If True, skip test generation and execution
+        skip_verify: If True, skip verification operations
+    
     Returns:
-        A SyncDecision object with the recommended operation and reason.
+        SyncDecision object with the recommended operation
     """
-    with SyncLock(basename, language):
-        # 1. Check Runtime Signals First (highest priority)
-        run_report = read_run_report(basename, language)
-        if run_report:
-            if run_report.exit_code != 0:
+    # 1. Check Runtime Signals First (Highest Priority)
+    # Workflow Order (from whitepaper):
+    # 1. auto-deps (find context/dependencies)
+    # 2. generate (create code module)  
+    # 3. example (create usage example)
+    # 4. crash (resolve crashes if code doesn't run)
+    # 5. verify (verify example runs correctly after crash fix)
+    # 6. test (generate unit tests)
+    # 7. fix (resolve bugs found by tests)
+    # 8. update (sync changes back to prompt)
+    
+    # Read fingerprint early since we need it for crash verification
+    fingerprint = read_fingerprint(basename, language)
+    
+    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',
+                details={'tests_failed': run_report.tests_failed},
+                estimated_cost=1.5,
+                confidence=0.90
+            )
+        
+        # Then check for runtime crashes (only if no test failures)
+        if run_report.exit_code != 0:
+            # Check if this was from a crash fix that needs verification
+            if fingerprint and fingerprint.command == 'crash':
+                return SyncDecision(
+                    operation='verify',
+                    reason='Previous crash was fixed - verify example runs correctly',
+                    details={'previous_command': 'crash', 'previous_exit_code': run_report.exit_code},
+                    estimated_cost=0.7,
+                    confidence=0.90
+                )
+            else:
                 return SyncDecision(
                     operation='crash',
-                    reason=f"The last run exited with a non-zero code ({run_report.exit_code}). "
-                           "This indicates a crash that must be fixed.",
-                    details=asdict(run_report)
+                    reason='Runtime error detected in last run',
+                    details={'exit_code': run_report.exit_code},
+                    estimated_cost=2.0,
+                    confidence=0.95
                 )
-            if run_report.tests_failed > 0:
+        
+        if run_report.coverage < target_coverage:
+            if skip_tests:
+                # When tests are skipped but coverage is low, consider workflow complete
+                # since we can't improve coverage without running tests
                 return SyncDecision(
-                    operation='fix',
-                    reason=f"The last test run had {run_report.tests_failed} failing tests. "
-                           "These must be fixed.",
-                    details=asdict(run_report)
+                    operation='all_synced',
+                    reason=f'Coverage {run_report.coverage:.1f}% below target {target_coverage:.1f}% but tests skipped',
+                    details={'current_coverage': run_report.coverage, 'target_coverage': target_coverage, 'tests_skipped': True},
+                    estimated_cost=0.0,
+                    confidence=0.90
                 )
-            if run_report.coverage < target_coverage:
+            else:
                 return SyncDecision(
                     operation='test',
-                    reason=f"Current test coverage ({run_report.coverage}%) is below the "
-                           f"target ({target_coverage}%). More tests are needed.",
-                    details=asdict(run_report)
+                    reason=f'Coverage {run_report.coverage:.1f}% below target {target_coverage:.1f}%',
+                    details={'current_coverage': run_report.coverage, 'target_coverage': target_coverage},
+                    estimated_cost=1.0,
+                    confidence=0.85
                 )
-
-        # 2. Analyze File State
-        paths = get_pdd_file_paths(basename, language)
-        fingerprint = read_fingerprint(basename, language)
-        current_hashes = calculate_current_hashes(paths)
+    
+    # 2. Analyze File State
+    paths = get_pdd_file_paths(basename, language, prompts_dir)
+    current_hashes = calculate_current_hashes(paths)
+    
+    # 3. Implement the Decision Tree
+    if not fingerprint:
+        # No Fingerprint (New or Untracked Unit)
+        if paths['prompt'].exists():
+            prompt_content = paths['prompt'].read_text(encoding='utf-8', errors='ignore')
+            if check_for_dependencies(prompt_content):
+                return SyncDecision(
+                    operation='auto-deps',
+                    reason='New prompt with dependencies detected',
+                    details={'prompt_path': str(paths['prompt'])},
+                    estimated_cost=0.5,
+                    confidence=0.80
+                )
+            else:
+                return SyncDecision(
+                    operation='generate',
+                    reason='New prompt ready for code generation',
+                    details={'prompt_path': str(paths['prompt'])},
+                    estimated_cost=1.0,
+                    confidence=0.90
+                )
+        else:
+            return SyncDecision(
+                operation='nothing',
+                reason='No prompt file and no history - nothing to do',
+                details={},
+                estimated_cost=0.0,
+                confidence=1.0
+            )
+    
+    # CRITICAL FIX: Validate expected files exist before hash comparison
+    if fingerprint:
+        file_validation = validate_expected_files(fingerprint, paths)
+        missing_expected_files = [
+            file_type for file_type, exists in file_validation.items() 
+            if not exists
+        ]
         
-        # 3. Implement the Decision Tree
+        if missing_expected_files:
+            # Files are missing that should exist - need to regenerate
+            # This prevents the incorrect analyze_conflict decision
+            return _handle_missing_expected_files(
+                missing_expected_files, paths, fingerprint, basename, language, prompts_dir, skip_tests, skip_verify
+            )
+    
+    # Compare hashes only for files that actually exist (prevents None != "hash" false positives)
+    changes = []
+    if fingerprint:
+        if current_hashes.get('prompt_hash') != fingerprint.prompt_hash:
+            changes.append('prompt')
+        # Only compare hashes for files that exist
+        if paths['code'].exists() and current_hashes.get('code_hash') != fingerprint.code_hash:
+            changes.append('code')
+        if paths['example'].exists() and current_hashes.get('example_hash') != fingerprint.example_hash:
+            changes.append('example')
+        if paths['test'].exists() and current_hashes.get('test_hash') != fingerprint.test_hash:
+            changes.append('test')
+    
+    if not changes:
+        # No Changes (Hashes Match Fingerprint) - Progress workflow with skip awareness
+        if _is_workflow_complete(paths, skip_tests, skip_verify):
+            return SyncDecision(
+                operation='nothing',
+                reason=f'All required files synchronized (skip_tests={skip_tests}, skip_verify={skip_verify})',
+                details={'skip_tests': skip_tests, 'skip_verify': skip_verify},
+                estimated_cost=0.0,
+                confidence=1.0
+            )
+        
+        # Progress workflow considering skip flags
+        if paths['code'].exists() and not paths['example'].exists():
+            return SyncDecision(
+                operation='example',
+                reason='Code exists but example missing - progress workflow',
+                details={'code_path': str(paths['code'])},
+                estimated_cost=0.5,
+                confidence=0.85
+            )
         
-        # Case: No Fingerprint (new or untracked unit)
-        if not fingerprint:
+        if (paths['code'].exists() and paths['example'].exists() and 
+            not skip_tests and not paths['test'].exists()):
+            return SyncDecision(
+                operation='test',
+                reason='Code and example exist but test missing - progress workflow',
+                details={'code_path': str(paths['code']), 'example_path': str(paths['example'])},
+                estimated_cost=1.0,
+                confidence=0.85
+            )
+        
+        # Some files are missing but no changes detected
+        if not paths['code'].exists():
             if paths['prompt'].exists():
+                prompt_content = paths['prompt'].read_text(encoding='utf-8', errors='ignore')
+                if check_for_dependencies(prompt_content):
+                    return SyncDecision(
+                        operation='auto-deps',
+                        reason='Missing code file, prompt has dependencies',
+                        details={'prompt_path': str(paths['prompt'])},
+                        estimated_cost=0.5,
+                        confidence=0.80
+                    )
+                else:
+                    return SyncDecision(
+                        operation='generate',
+                        reason='Missing code file - generate from prompt',
+                        details={'prompt_path': str(paths['prompt'])},
+                        estimated_cost=1.0,
+                        confidence=0.90
+                    )
+    
+    elif len(changes) == 1:
+        # Simple Changes (Single File Modified)
+        change = changes[0]
+        
+        if change == 'prompt':
+            prompt_content = paths['prompt'].read_text(encoding='utf-8', errors='ignore')
+            if check_for_dependencies(prompt_content):
                 return SyncDecision(
-                    operation='generate',
-                    reason="No fingerprint file found, but a prompt exists. This appears to be a new PDD unit."
+                    operation='auto-deps',
+                    reason='Prompt changed and dependencies need updating',
+                    details={'changed_file': 'prompt'},
+                    estimated_cost=0.5,
+                    confidence=0.85
                 )
             else:
                 return SyncDecision(
-                    operation='nothing',
-                    reason="No PDD fingerprint and no prompt file found. Nothing to do."
+                    operation='generate',
+                    reason='Prompt changed - regenerate code',
+                    details={'changed_file': 'prompt'},
+                    estimated_cost=1.0,
+                    confidence=0.90
                 )
-
-        # Compare current hashes with fingerprint
-        fingerprint_hashes = {
-            'prompt_hash': fingerprint.prompt_hash,
-            'code_hash': fingerprint.code_hash,
-            'example_hash': fingerprint.example_hash,
-            'test_hash': fingerprint.test_hash,
-        }
         
-        changed_files = [
-            file_type.replace('_hash', '')
-            for file_type, f_hash in fingerprint_hashes.items()
-            if current_hashes.get(file_type) != f_hash
-        ]
+        elif change == 'code':
+            return SyncDecision(
+                operation='update',
+                reason='Code changed - update prompt to reflect changes',
+                details={'changed_file': 'code'},
+                estimated_cost=0.8,
+                confidence=0.85
+            )
         
-        # Case: No Changes
-        if not changed_files:
+        elif change == 'test':
             return SyncDecision(
-                operation='nothing',
-                reason="All files are synchronized with the last known good state."
+                operation='test',
+                reason='Test changed - run new tests',
+                details={'changed_file': 'test'},
+                estimated_cost=0.5,
+                confidence=0.80
             )
+        
+        elif change == 'example':
+            return SyncDecision(
+                operation='verify',
+                reason='Example changed - verify new example',
+                details={'changed_file': 'example'},
+                estimated_cost=0.7,
+                confidence=0.80
+            )
+    
+    else:
+        # Complex Changes (Multiple Files Modified / Conflicts)
+        return SyncDecision(
+            operation='analyze_conflict',
+            reason='Multiple files changed - requires conflict analysis',
+            details={'changed_files': changes},
+            estimated_cost=2.0,
+            confidence=0.70
+        )
+    
+    # Fallback - should not reach here normally
+    return SyncDecision(
+        operation='nothing',
+        reason='No clear operation determined',
+        details={'fingerprint_exists': fingerprint is not None, 'changes': changes},
+        estimated_cost=0.0,
+        confidence=0.50
+    )
+
 
-        details = {"changed_files": changed_files}
-        # Case: Simple Changes (Single File Modified)
-        if len(changed_files) == 1:
-            change = changed_files[0]
-            if change == 'prompt':
-                return SyncDecision('generate', "The prompt has been modified. Code should be regenerated.", details)
-            if change == 'code':
-                return SyncDecision('update', "The code has been modified manually. The prompt should be updated.", details)
-            if change == 'test':
-                return SyncDecision('test', "The test file has been modified. The new tests should be run.", details)
-            if change == 'example':
-                # 'verify' is a pdd command to run the example file
-                return SyncDecision('verify', "The example file has been modified. It should be verified.", details)
-
-        # Case: Complex Changes (Multiple Files Modified / Conflicts)
-        if len(changed_files) > 1:
+def analyze_conflict_with_llm(basename: str, language: str, fingerprint: Fingerprint, changed_files: List[str], prompts_dir: str = "prompts") -> SyncDecision:
+    """
+    Resolve complex sync conflicts using an LLM.
+    
+    Args:
+        basename: The base name for the PDD unit
+        language: The programming language
+        fingerprint: The last known good state
+        changed_files: List of files that have changed
+        prompts_dir: Directory containing prompt files
+    
+    Returns:
+        SyncDecision object with LLM-recommended operation
+    """
+    
+    try:
+        # 1. Load LLM Prompt
+        prompt_template = load_prompt_template("sync_analysis_LLM")
+        if not prompt_template:
+            # Fallback if template not found
             return SyncDecision(
-                operation='analyze_conflict',
-                reason=f"Multiple files have been modified since the last sync: {', '.join(changed_files)}.",
-                details=details
+                operation='fail_and_request_manual_merge',
+                reason='LLM analysis template not found - manual merge required',
+                details={'error': 'Template not available'},
+                estimated_cost=0.0,
+                confidence=0.0
             )
+        
+        # 2. Gather file paths and diffs
+        paths = get_pdd_file_paths(basename, language, prompts_dir)
+        
+        # Generate diffs for changed files
+        diffs = {}
+        for file_type in changed_files:
+            if file_type in paths and paths[file_type].exists():
+                diffs[f"{file_type}_diff"] = get_git_diff(paths[file_type])
+                diffs[f"{file_type}_path"] = str(paths[file_type])
+            else:
+                diffs[f"{file_type}_diff"] = ""
+                diffs[f"{file_type}_path"] = str(paths.get(file_type, ''))
+        
+        # 3. Format the prompt
+        formatted_prompt = prompt_template.format(
+            fingerprint=json.dumps({
+                'pdd_version': fingerprint.pdd_version,
+                'timestamp': fingerprint.timestamp,
+                'command': fingerprint.command,
+                'prompt_hash': fingerprint.prompt_hash,
+                'code_hash': fingerprint.code_hash,
+                'example_hash': fingerprint.example_hash,
+                'test_hash': fingerprint.test_hash
+            }, indent=2),
+            changed_files_list=', '.join(changed_files),
+            prompt_diff=diffs.get('prompt_diff', ''),
+            code_diff=diffs.get('code_diff', ''),
+            example_diff=diffs.get('example_diff', ''),
+            test_diff=diffs.get('test_diff', ''),
+            prompt_path=diffs.get('prompt_path', ''),
+            code_path=diffs.get('code_path', ''),
+            example_path=diffs.get('example_path', ''),
+            test_path=diffs.get('test_path', '')
+        )
+        
+        # 4. Invoke LLM with caching for determinism
+        response = llm_invoke(
+            prompt=formatted_prompt,
+            input_json={},
+            strength=0.7,  # Use a consistent strength for determinism
+            temperature=0.0,  # Use temperature 0 for deterministic output
+            verbose=False
+        )
+        
+        # 5. Parse and validate response
+        try:
+            llm_result = json.loads(response['result'])
             
-        # Fallback, should not be reached
-        return SyncDecision('nothing', 'Analysis complete, no operation required.')
+            # Validate required keys
+            required_keys = ['next_operation', 'reason', 'confidence']
+            if not all(key in llm_result for key in required_keys):
+                raise ValueError("Missing required keys in LLM response")
+            
+            # Check confidence threshold
+            confidence = float(llm_result.get('confidence', 0.0))
+            if confidence < 0.75:
+                return SyncDecision(
+                    operation='fail_and_request_manual_merge',
+                    reason=f'LLM confidence too low ({confidence:.2f}) - manual merge required',
+                    details={'llm_response': llm_result, 'changed_files': changed_files},
+                    estimated_cost=response.get('cost', 0.0),
+                    confidence=confidence
+                )
+            
+            # Extract operation and details
+            operation = llm_result['next_operation']
+            reason = llm_result['reason']
+            merge_strategy = llm_result.get('merge_strategy', {})
+            follow_up_operations = llm_result.get('follow_up_operations', [])
+            
+            return SyncDecision(
+                operation=operation,
+                reason=f"LLM analysis: {reason}",
+                details={
+                    'llm_response': llm_result,
+                    'changed_files': changed_files,
+                    'merge_strategy': merge_strategy,
+                    'follow_up_operations': follow_up_operations
+                },
+                estimated_cost=response.get('cost', 0.0),
+                confidence=confidence,
+                prerequisites=follow_up_operations
+            )
+            
+        except (json.JSONDecodeError, ValueError, KeyError) as e:
+            # Invalid LLM response - fallback to manual merge
+            return SyncDecision(
+                operation='fail_and_request_manual_merge',
+                reason=f'Invalid LLM response: {e} - manual merge required',
+                details={'error': str(e), 'raw_response': response.get('result', ''), 'changed_files': changed_files},
+                estimated_cost=response.get('cost', 0.0),
+                confidence=0.0
+            )
+    
+    except Exception as e:
+        # Any other error - fallback to manual merge
+        return SyncDecision(
+            operation='fail_and_request_manual_merge',
+            reason=f'Error during LLM analysis: {e} - manual merge required',
+            details={'error': str(e), 'changed_files': changed_files},
+            estimated_cost=0.0,
+            confidence=0.0
+        )
+
+
+if __name__ == "__main__":
+    # Example usage
+    if len(sys.argv) != 3:
+        print("Usage: python sync_determine_operation.py <basename> <language>")
+        sys.exit(1)
+    
+    basename = sys.argv[1]
+    language = sys.argv[2]
+    
+    decision = sync_determine_operation(basename, language, target_coverage=90.0)
+    
+    print(f"Operation: {decision.operation}")
+    print(f"Reason: {decision.reason}")
+    print(f"Estimated Cost: ${decision.estimated_cost:.2f}")
+    print(f"Confidence: {decision.confidence:.2f}")
+    if decision.details:
+        print(f"Details: {json.dumps(decision.details, indent=2)}")