refactor: restructure core modules into context and memory packages

- Move pm_init components to dedicated packages
- context/: PM mode initialization and contracts
- memory/: Reflexion memory system
- Remove deprecated superclaude/core/pm_init/

Breaking change: Import paths updated
- Old: superclaude.core.pm_init.context_contract
- New: superclaude.context.contract

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

superclaude/context/init.py

@@ -0,0 +1,134 @@
+"""Context Initialization
+
+Runs at session start to:
+1. Detect repository root and structure
+2. Generate Context Contract
+3. Load Reflexion Memory
+4. Set up project context
+"""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional, Dict, Any
+import yaml
+
+from .contract import ContextContract
+from superclaude.memory import ReflexionMemory
+
+
+class PMInitializer:
+    """Initializes PM Mode with project context"""
+
+    def __init__(self, cwd: Optional[Path] = None):
+        self.cwd = cwd or Path.cwd()
+        self.git_root: Optional[Path] = None
+        self.config: Dict[str, Any] = {}
+
+    def detect_git_root(self) -> Optional[Path]:
+        """Detect Git repository root"""
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                cwd=self.cwd,
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            if result.returncode == 0:
+                return Path(result.stdout.strip())
+        except Exception:
+            pass
+        return None
+
+    def scan_project_structure(self) -> Dict[str, Any]:
+        """Lightweight scan of project structure (paths only, no content)"""
+        if not self.git_root:
+            return {}
+
+        structure = {
+            "docker_compose": [],
+            "infrastructure": {
+                "traefik": [],
+                "kong": [],
+                "supabase": [],
+                "infisical": []
+            },
+            "package_managers": {
+                "node": [],
+                "python": []
+            },
+            "config_files": []
+        }
+
+        # Docker Compose files
+        for pattern in ["docker-compose*.yml", "docker-compose*.yaml"]:
+            structure["docker_compose"].extend([
+                str(p.relative_to(self.git_root))
+                for p in self.git_root.glob(pattern)
+            ])
+
+        # Infrastructure directories
+        for infra_type in ["traefik", "kong", "supabase", "infisical"]:
+            infra_path = self.git_root / "infra" / infra_type
+            if infra_path.exists():
+                structure["infrastructure"][infra_type].append(str(infra_path.relative_to(self.git_root)))
+
+        # Package managers
+        if (self.git_root / "package.json").exists():
+            structure["package_managers"]["node"].append("package.json")
+        if (self.git_root / "pnpm-lock.yaml").exists():
+            structure["package_managers"]["node"].append("pnpm-lock.yaml")
+        if (self.git_root / "pyproject.toml").exists():
+            structure["package_managers"]["python"].append("pyproject.toml")
+        if (self.git_root / "uv.lock").exists():
+            structure["package_managers"]["python"].append("uv.lock")
+
+        return structure
+
+    def initialize(self) -> Dict[str, Any]:
+        """Main initialization routine"""
+        # Step 1: Detect Git root
+        self.git_root = self.detect_git_root()
+        if not self.git_root:
+            return {
+                "status": "not_git_repo",
+                "message": "Not a Git repository - PM Mode running in standalone mode"
+            }
+
+        # Step 2: Scan project structure (lightweight)
+        structure = self.scan_project_structure()
+
+        # Step 3: Generate or load Context Contract
+        contract = ContextContract(self.git_root, structure)
+        contract_data = contract.generate_or_load()
+
+        # Step 4: Load Reflexion Memory
+        memory = ReflexionMemory(self.git_root)
+        memory_data = memory.load()
+
+        # Step 5: Return initialization data
+        return {
+            "status": "initialized",
+            "git_root": str(self.git_root),
+            "structure": structure,
+            "context_contract": contract_data,
+            "reflexion_memory": memory_data,
+            "message": "PM Mode initialized successfully"
+        }
+
+
+def initialize_context(cwd: Optional[Path] = None) -> Dict[str, Any]:
+    """
+    Initialize project context.
+
+    This function runs at session start.
+
+    Args:
+        cwd: Current working directory (defaults to os.getcwd())
+
+    Returns:
+        Initialization status and configuration
+    """
+    initializer = PMInitializer(cwd)
+    return initializer.initialize()