Claude Code: Review the memory system implementation, specifically focusing on git op

memory/__init__.py

@@ -0,0 +1,39 @@
+"""
+Cain's Memory System Package.
+
+Provides persistent memory storage with git synchronization and log management.
+
+Key exports:
+- MemorySystem: Main memory management class
+- GitMemoryBridge: Git-based persistence layer with timeout controls
+- LogManager: Log rotation and cleanup utilities
+"""
+
+from .memory_system import MemorySystem, get_memory
+from .git_repo import GitMemoryBridge, GitOperationError, GitTimeoutError, TIMEOUT_CONFIG
+from .log_manager import (
+    LogManager,
+    LogRetentionConfig,
+    rotate_logs,
+    get_log_health
+)
+
+__all__ = [
+    # Memory system
+    "MemorySystem",
+    "get_memory",
+
+    # Git operations
+    "GitMemoryBridge",
+    "GitOperationError",
+    "GitTimeoutError",
+    "TIMEOUT_CONFIG",
+
+    # Log management
+    "LogManager",
+    "LogRetentionConfig",
+    "rotate_logs",
+    "get_log_health",
+]
+
+__version__ = "1.1.0"

memory/git_repo.py

@@ -1,89 +1,249 @@
 """
 Git-based Memory Bridge for HuggingFace Spaces.
 Allows the AI to persist memory to the Dataset repository.
+
+Enhanced with timeout controls and retry mechanisms for reliability.
 """
 import logging
 import subprocess
 import json
 import time
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 
 logger = logging.getLogger(__name__)
 
+# Timeout values for different git operations (in seconds)
+TIMEOUT_CONFIG = {
+    "fetch": 60,      # Network operation, can be slow
+    "pull": 90,       # Pull includes merge, may take time
+    "push": 120,      # Push is network-heavy
+    "commit": 30,     # Local operation, should be fast
+    "status": 15,     # Quick local check
+    "add": 20,        # Local operation
+    "reset": 30,      # Local operation
+    "default": 45,    # Fallback for unknown operations
+}
+
+class GitOperationError(Exception):
+    """Custom exception for git operation failures."""
+    pass
+
+class GitTimeoutError(GitOperationError):
+    """Exception raised when git operation times out."""
+    pass
+
 class GitMemoryBridge:
-    def __init__(self, repo_path: str = "/data", max_retries: int = 3):
+    """Git-based memory persistence with timeout and retry support."""
+
+    def __init__(self, repo_path: str = "/data", max_retries: int = 3, base_timeout: int = None):
+        """
+        Initialize the Git memory bridge.
+
+        Args:
+            repo_path: Path to the git repository
+            max_retries: Maximum number of retry attempts for failed operations
+            base_timeout: Override default timeout (in seconds). None uses operation-specific timeouts.
+        """
         self.repo_path = repo_path
         self.max_retries = max_retries
+        self.base_timeout = base_timeout
         self.git = self._get_git_command()
 
-    def _get_git_command(self) -> str:
+    def _get_git_command(self) -> Optional[str]:
         """Check if git is available."""
         try:
-            subprocess.run(["git", "--version"], capture_output=True, check=True)
+            result = subprocess.run(
+                ["git", "--version"],
+                capture_output=True,
+                check=True,
+                timeout=10
+            )
+            logger.info(f"Git version: {result.stdout.strip()}")
             return "git"
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            logger.warning("System git not found, attempting fallback logic if available.")
+        except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired) as e:
+            logger.warning(f"System git not found or timed out: {e}")
             return None
 
-    def _run_git(self, args: list, check: bool = True) -> subprocess.CompletedProcess:
+    def _get_timeout_for_command(self, command: str) -> int:
+        """Get appropriate timeout based on git command."""
+        cmd = command.lower()
+        if self.base_timeout:
+            return self.base_timeout
+        return TIMEOUT_CONFIG.get(cmd, TIMEOUT_CONFIG["default"])
+
+    def _run_git(
+        self,
+        args: List[str],
+        check: bool = True,
+        timeout: Optional[int] = None,
+        retry_count: int = 0
+    ) -> subprocess.CompletedProcess:
+        """
+        Run a git command with timeout and retry logic.
+
+        Args:
+            args: Git command arguments (e.g., ['push', 'origin', 'main'])
+            check: Whether to raise an error on non-zero exit code
+            timeout: Override timeout for this specific call
+            retry_count: Current retry attempt (internal use)
+
+        Returns:
+            CompletedProcess result
+
+        Raises:
+            GitTimeoutError: If operation times out after all retries
+            GitOperationError: If operation fails after all retries
+            RuntimeError: If git is not available
+        """
         if not self.git:
             raise RuntimeError("Git is not available in this environment.")
-        
+
+        # Determine timeout
+        if timeout is None and args:
+            timeout = self._get_timeout_for_command(args[0])
+        elif timeout is None:
+            timeout = TIMEOUT_CONFIG["default"]
+
         full_cmd = [self.git] + args
-        logger.debug(f"Running git command: {' '.join(full_cmd)}")
-        
-        return subprocess.run(
-            full_cmd, 
-            cwd=self.repo_path, 
-            capture_output=True, 
-            text=True, 
-            check=check
-        )
+        cmd_str = ' '.join(full_cmd)
+        logger.debug(f"Running git command: {cmd_str} (timeout: {timeout}s, attempt: {retry_count + 1}/{self.max_retries + 1})")
+
+        attempt = 0
+        last_error = None
+
+        while attempt <= self.max_retries:
+            try:
+                start_time = time.time()
+                result = subprocess.run(
+                    full_cmd,
+                    cwd=self.repo_path,
+                    capture_output=True,
+                    text=True,
+                    check=check,
+                    timeout=timeout
+                )
+                elapsed = time.time() - start_time
+
+                if result.stdout:
+                    logger.debug(f"Git stdout: {result.stdout.strip()[:200]}")
+
+                logger.info(f"Git command completed successfully in {elapsed:.2f}s: {args[0]}")
+
+                return result
+
+            except subprocess.TimeoutExpired as e:
+                last_error = e
+                elapsed = time.time() - start_time
+                logger.warning(
+                    f"Git command timed out after {elapsed:.2f}s: {args[0]} "
+                    f"(attempt {attempt + 1}/{self.max_retries + 1})"
+                )
+
+                if attempt < self.max_retries:
+                    # Exponential backoff: 2^attempt seconds, max 30s
+                    backoff = min(2 ** attempt, 30)
+                    logger.info(f"Retrying in {backoff}s...")
+                    time.sleep(backoff)
+                else:
+                    error_msg = f"Git operation timed out after {self.max_retries + 1} attempts: {args[0]}"
+                    logger.error(error_msg)
+                    raise GitTimeoutError(error_msg) from e
+
+            except subprocess.CalledProcessError as e:
+                last_error = e
+                logger.warning(
+                    f"Git command failed with exit code {e.returncode}: {args[0]} "
+                    f"(attempt {attempt + 1}/{self.max_retries + 1})"
+                )
+
+                if e.stderr:
+                    logger.debug(f"Git stderr: {e.stderr.strip()[:200]}")
+
+                # Don't retry on certain errors
+                if any(msg in (e.stderr or "") for msg in ["fatal:", "error:"]):
+                    # Permanent error, don't retry
+                    raise GitOperationError(f"Git command failed: {e.stderr.strip()}") from e
+
+                if attempt < self.max_retries:
+                    backoff = min(2 ** attempt, 30)
+                    logger.info(f"Retrying in {backoff}s...")
+                    time.sleep(backoff)
+                else:
+                    error_msg = f"Git operation failed after {self.max_retries + 1} attempts: {args[0]}"
+                    logger.error(error_msg)
+                    raise GitOperationError(error_msg) from e
+
+            attempt += 1
+
+        # Should not reach here, but just in case
+        if last_error:
+            raise GitOperationError(f"Git operation failed: {last_error}") from last_error
 
     def sync_memory(self) -> bool:
         """
         Pulls latest changes from the remote dataset repository.
         Returns True if successful, False otherwise.
+
+        Uses timeout-controlled git operations with retry logic.
         """
         try:
             logger.info("Syncing memory from remote dataset...")
-            
-            # Configure git to handle credentials (usually auto-handled in Spaces, but good to be safe)
-            # We assume the environment is already authenticated for the huggingface-cli / git
-            
+
+            # First, fetch to get latest remote state with timeout
+            fetch_result = self._run_git(
+                ["fetch", "origin", "main"],
+                check=False,
+                timeout=TIMEOUT_CONFIG["fetch"]
+            )
+
+            if fetch_result.returncode != 0:
+                logger.warning(f"Fetch failed: {fetch_result.stderr}")
+                return False
+
             # Pull with strategy X (theirs) to prefer remote state (survival priority)
-            result = self._run_git([
-                "pull", 
-                "origin", 
-                "main", 
-                "--strategy-option=theirs"
-            ], check=False)
-
-            if result.returncode == 0:
-                logger.info(f"Memory sync successful: {result.stdout.strip()}")
+            pull_result = self._run_git(
+                ["pull", "origin", "main", "--strategy-option=theirs"],
+                check=False,
+                timeout=TIMEOUT_CONFIG["pull"]
+            )
+
+            if pull_result.returncode == 0:
+                logger.info(f"Memory sync successful: {pull_result.stdout.strip()}")
                 return True
             else:
                 # If it fails due to divergent branches or history, try a harder reset
-                if "divergent" in result.stderr or "refusing to merge" in result.stderr:
+                if "divergent" in pull_result.stderr or "refusing to merge" in pull_result.stderr:
                     logger.warning("Git history diverged. Performing hard reset to remote origin/main.")
-                    self._run_git(["fetch", "origin", "main"])
-                    self._run_git(["reset", "--hard", "origin/main"])
+                    self._run_git(["reset", "--hard", "origin/main"], timeout=TIMEOUT_CONFIG["reset"])
                     return True
                 else:
-                    logger.error(f"Memory sync failed: {result.stderr}")
+                    logger.error(f"Memory sync failed: {pull_result.stderr}")
                     return False
 
+        except GitTimeoutError as e:
+            logger.error(f"Memory sync timed out: {e}")
+            return False
+        except GitOperationError as e:
+            logger.error(f"Memory sync operation failed: {e}")
+            return False
         except Exception as e:
-            logger.error(f"Exception during memory sync: {e}")
+            logger.error(f"Unexpected exception during memory sync: {e}")
             return False
 
     def save_memory(self, commit_message: str = "Update memory state") -> bool:
         """
         Commits and pushes local changes to the remote dataset repository.
+        Uses timeout-controlled git operations with retry logic.
+
+        Args:
+            commit_message: Message for the git commit
+
+        Returns:
+            True if successful, False otherwise
         """
         try:
             # 1. Check status
-            status = self._run_git(["status", "--porcelain"])
+            status = self._run_git(["status", "--porcelain"], timeout=TIMEOUT_CONFIG["status"])
             if not status.stdout.strip():
                 logger.info("No new memories to save.")
                 return True
@@ -91,16 +251,23 @@ class GitMemoryBridge:
             logger.info(f"Saving memory changes: {status.stdout}")
 
             # 2. Add changes
-            self._run_git(["add", "-A"])
+            self._run_git(["add", "-A"], timeout=TIMEOUT_CONFIG["add"])
 
             # 3. Commit
             # Use --no-verify to skip pre-commit hooks that might fail
-            self._run_git(["commit", "-m", commit_message, "--no-verify"])
-            
+            self._run_git(
+                ["commit", "-m", commit_message, "--no-verify"],
+                timeout=TIMEOUT_CONFIG["commit"]
+            )
+
             # 4. Push
             logger.info("Pushing memory to remote...")
-            push_result = self._run_git(["push", "origin", "main"], check=False)
-            
+            push_result = self._run_git(
+                ["push", "origin", "main"],
+                check=False,
+                timeout=TIMEOUT_CONFIG["push"]
+            )
+
             if push_result.returncode == 0:
                 logger.info("Memory saved successfully.")
                 return True
@@ -110,12 +277,23 @@ class GitMemoryBridge:
                     logger.warning("Remote updated during save. Pulling and retrying...")
                     self.sync_memory()
                     # Retry push once
-                    retry_result = self._run_git(["push", "origin", "main"], check=False)
+                    retry_result = self._run_git(
+                        ["push", "origin", "main"],
+                        check=False,
+                        timeout=TIMEOUT_CONFIG["push"]
+                    )
                     return retry_result.returncode == 0
+                logger.error(f"Push failed: {push_result.stderr}")
                 return False
 
+        except GitTimeoutError as e:
+            logger.error(f"Memory save timed out: {e}")
+            return False
+        except GitOperationError as e:
+            logger.error(f"Memory save operation failed: {e}")
+            return False
         except Exception as e:
-            logger.error(f"Exception during memory save: {e}")
+            logger.error(f"Unexpected exception during memory save: {e}")
             return False
 
     def read_file(self, path: str) -> Optional[str]:

memory/log_manager.py

@@ -0,0 +1,320 @@
+"""
+Log Management Module for Cain Memory System.
+
+Provides log rotation, compression, and cleanup functionality to prevent
+unbounded log growth and maintain system health.
+
+Features:
+- Retains logs for 7 days
+- Compresses logs older than 3 days using gzip
+- Cleans up .bak files, keeping only the 3 most recent
+- Provides health statistics about log storage
+"""
+
+import os
+import gzip
+import shutil
+import logging
+from datetime import datetime, timedelta
+from typing import List, Dict, Tuple
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class LogRetentionConfig:
+    """Configuration for log retention policy."""
+
+    # Retention periods
+    MAX_LOG_AGE_DAYS = 7          # Delete logs older than 7 days
+    COMPRESS_AGE_DAYS = 3         # Compress logs older than 3 days
+    MAX_BAK_FILES = 3             # Keep only 3 most recent .bak files
+
+    # Log directories to manage
+    LOG_DIRECTORIES = [
+        "/home/node/logs",
+        "/tmp/claude-workspace/.openclaw/logs",
+        "/data/logs",
+        "/app/logs",
+    ]
+
+    # File patterns to consider as logs
+    LOG_PATTERNS = ["*.log", "*.txt", "*.json"]
+
+    @classmethod
+    def add_log_directory(cls, path: str):
+        """Add a custom log directory to manage."""
+        if path not in cls.LOG_DIRECTORIES:
+            cls.LOG_DIRECTORIES.append(path)
+
+
+class LogManager:
+    """Manages log rotation, compression, and cleanup."""
+
+    def __init__(self, config: LogRetentionConfig = None):
+        """
+        Initialize the log manager.
+
+        Args:
+            config: Log retention configuration. Uses defaults if None.
+        """
+        self.config = config or LogRetentionConfig()
+        self.stats = {
+            "processed_dirs": 0,
+            "logs_compressed": 0,
+            "logs_deleted": 0,
+            "bak_files_deleted": 0,
+            "space_freed_bytes": 0,
+            "errors": []
+        }
+
+    def rotate_all_logs(self) -> Dict[str, any]:
+        """
+        Run log rotation on all configured directories.
+
+        Returns:
+            Dictionary with rotation statistics.
+        """
+        self.stats = {
+            "processed_dirs": 0,
+            "logs_compressed": 0,
+            "logs_deleted": 0,
+            "bak_files_deleted": 0,
+            "space_freed_bytes": 0,
+            "errors": []
+        }
+
+        logger.info("Starting log rotation process...")
+
+        for log_dir in self.config.LOG_DIRECTORIES:
+            if os.path.isdir(log_dir):
+                try:
+                    self._rotate_directory(log_dir)
+                    self.stats["processed_dirs"] += 1
+                except Exception as e:
+                    error_msg = f"Failed to rotate {log_dir}: {e}"
+                    logger.error(error_msg)
+                    self.stats["errors"].append(error_msg)
+            else:
+                logger.debug(f"Log directory not found: {log_dir}")
+
+        # Log summary
+        logger.info(
+            f"Log rotation complete. "
+            f"Dirs: {self.stats['processed_dirs']}, "
+            f"Compressed: {self.stats['logs_compressed']}, "
+            f"Deleted: {self.stats['logs_deleted']}, "
+            f"BAK cleaned: {self.stats['bak_files_deleted']}, "
+            f"Space freed: {self._format_bytes(self.stats['space_freed_bytes'])}"
+        )
+
+        return self.stats
+
+    def _rotate_directory(self, log_dir: str):
+        """Rotate logs in a single directory."""
+        logger.debug(f"Processing log directory: {log_dir}")
+
+        # Get all log files
+        log_files = self._get_log_files(log_dir)
+
+        for log_file in log_files:
+            try:
+                self._process_log_file(log_file)
+            except Exception as e:
+                error_msg = f"Failed to process {log_file}: {e}"
+                logger.warning(error_msg)
+                self.stats["errors"].append(error_msg)
+
+        # Clean up .bak files
+        self._cleanup_bak_files(log_dir)
+
+    def _get_log_files(self, log_dir: str) -> List[Path]:
+        """Get all log files in the directory."""
+        log_files = []
+        log_path = Path(log_dir)
+
+        for pattern in self.config.LOG_PATTERNS:
+            log_files.extend(log_path.glob(pattern))
+            # Also check for already compressed files
+            log_files.extend(log_path.glob(f"{pattern}.gz"))
+
+        # Filter out directories and sort by modification time
+        return sorted(
+            [f for f in log_files if f.is_file()],
+            key=lambda f: f.stat().st_mtime
+        )
+
+    def _process_log_file(self, log_file: Path):
+        """Process a single log file (compress or delete)."""
+        mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
+        age_days = (datetime.now() - mtime).days
+        size_before = log_file.stat().st_size
+
+        # Skip if already compressed
+        if log_file.suffix == ".gz":
+            if age_days > self.config.MAX_LOG_AGE_DAYS:
+                logger.debug(f"Deleting old compressed log: {log_file} ({age_days} days old)")
+                log_file.unlink()
+                self.stats["logs_deleted"] += 1
+                self.stats["space_freed_bytes"] += size_before
+            return
+
+        # Delete old logs
+        if age_days > self.config.MAX_LOG_AGE_DAYS:
+            logger.debug(f"Deleting old log: {log_file} ({age_days} days old)")
+            log_file.unlink()
+            self.stats["logs_deleted"] += 1
+            self.stats["space_freed_bytes"] += size_before
+            return
+
+        # Compress logs older than threshold
+        if age_days > self.config.COMPRESS_AGE_DAYS:
+            self._compress_log(log_file)
+            self.stats["logs_compressed"] += 1
+            # Calculate space saved
+            if log_file.with_suffix(log_file.suffix + ".gz").exists():
+                size_after = log_file.with_suffix(log_file.suffix + ".gz").stat().st_size
+                self.stats["space_freed_bytes"] += (size_before - size_after)
+
+    def _compress_log(self, log_file: Path):
+        """Compress a log file using gzip."""
+        compressed_path = log_file.with_suffix(log_file.suffix + ".gz")
+
+        if compressed_path.exists():
+            logger.debug(f"Compressed file already exists: {compressed_path}")
+            return
+
+        logger.debug(f"Compressing: {log_file}")
+        with open(log_file, 'rb') as f_in:
+            with gzip.open(compressed_path, 'wb') as f_out:
+                shutil.copyfileobj(f_in, f_out)
+
+        # Remove original after successful compression
+        log_file.unlink()
+        logger.debug(f"Compressed: {log_file} -> {compressed_path}")
+
+    def _cleanup_bak_files(self, log_dir: str):
+        """Clean up .bak files, keeping only the most recent ones."""
+        log_path = Path(log_dir)
+        bak_files = sorted(
+            log_path.glob("*.bak"),
+            key=lambda f: f.stat().st_mtime,
+            reverse=True  # Newest first
+        )
+
+        # Keep the N most recent, delete the rest
+        to_delete = bak_files[self.config.MAX_BAK_FILES:]
+
+        for bak_file in to_delete:
+            size = bak_file.stat().st_size
+            logger.debug(f"Deleting old .bak file: {bak_file}")
+            bak_file.unlink()
+            self.stats["bak_files_deleted"] += 1
+            self.stats["space_freed_bytes"] += size
+
+    def get_log_health_status(self) -> Dict[str, any]:
+        """
+        Get health status of log directories.
+
+        Returns:
+            Dictionary with log health information.
+        """
+        status = {
+            "directories": {},
+            "total_size_bytes": 0,
+            "total_files": 0,
+            "needs_rotation": False
+        }
+
+        for log_dir in self.config.LOG_DIRECTORIES:
+            if not os.path.isdir(log_dir):
+                continue
+
+            dir_info = self._get_directory_info(log_dir)
+            status["directories"][log_dir] = dir_info
+            status["total_size_bytes"] += dir_info["size_bytes"]
+            status["total_files"] += dir_info["file_count"]
+
+            if dir_info.get("has_old_logs", False):
+                status["needs_rotation"] = True
+
+        status["total_size_human"] = self._format_bytes(status["total_size_bytes"])
+        return status
+
+    def _get_directory_info(self, log_dir: str) -> Dict[str, any]:
+        """Get information about a log directory."""
+        log_path = Path(log_dir)
+        files = list(log_path.glob("*"))
+        total_size = sum(f.stat().st_size for f in files if f.is_file())
+
+        # Check for old logs
+        now = datetime.now()
+        has_old_logs = False
+        oldest_age_days = 0
+
+        for f in files:
+            if f.is_file():
+                mtime = datetime.fromtimestamp(f.stat().st_mtime)
+                age_days = (now - mtime).days
+                if age_days > self.config.COMPRESS_AGE_DAYS:
+                    has_old_logs = True
+                oldest_age_days = max(oldest_age_days, age_days)
+
+        return {
+            "size_bytes": total_size,
+            "size_human": self._format_bytes(total_size),
+            "file_count": len(files),
+            "has_old_logs": has_old_logs,
+            "oldest_age_days": oldest_age_days
+        }
+
+    @staticmethod
+    def _format_bytes(size_bytes: int) -> str:
+        """Format byte count to human-readable string."""
+        for unit in ['B', 'KB', 'MB', 'GB']:
+            if size_bytes < 1024.0:
+                return f"{size_bytes:.1f}{unit}"
+            size_bytes /= 1024.0
+        return f"{size_bytes:.1f}TB"
+
+
+def rotate_logs() -> Dict[str, any]:
+    """
+    Convenience function to rotate logs with default configuration.
+
+    Returns:
+        Dictionary with rotation statistics.
+    """
+    manager = LogManager()
+    return manager.rotate_all_logs()
+
+
+def get_log_health() -> Dict[str, any]:
+    """
+    Convenience function to get log health status.
+
+    Returns:
+        Dictionary with log health information.
+    """
+    manager = LogManager()
+    return manager.get_log_health_status()
+
+
+if __name__ == "__main__":
+    # Run log rotation when executed directly
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+
+    stats = rotate_logs()
+    print(f"\n=== Log Rotation Summary ===")
+    print(f"Directories processed: {stats['processed_dirs']}")
+    print(f"Logs compressed: {stats['logs_compressed']}")
+    print(f"Logs deleted: {stats['logs_deleted']}")
+    print(f"BAK files deleted: {stats['bak_files_deleted']}")
+    print(f"Space freed: {LogManager._format_bytes(stats['space_freed_bytes'])}")
+
+    if stats['errors']:
+        print(f"\nErrors encountered: {len(stats['errors'])}")
+        for error in stats['errors']:
+            print(f"  - {error}")

memory/memory_system.py

@@ -1,19 +1,43 @@
 """
 Cain's Memory System - Handles loading, saving, and processing of memory data.
 Now supports persistent storage via HuggingFace Datasets.
+
+Enhanced with:
+- Timeout-controlled git operations
+- Log rotation and management
+- Comprehensive error handling and logging
 """
 
 import os
 import json
 import fcntl
+import logging
 from typing import Dict, Any, Optional
 from datetime import datetime
-from .git_repo import GitMemoryBridge  # Import the Git utility
+from .git_repo import GitMemoryBridge, GitOperationError, GitTimeoutError
+from .log_manager import LogManager, LogRetentionConfig
+
+logger = logging.getLogger(__name__)
 
 class MemorySystem:
     """Manages Cain's memory with automatic persistence to Dataset."""
 
-    def __init__(self, repo_path: str = "/data"):
+    def __init__(
+        self,
+        repo_path: str = "/data",
+        git_timeout: int = None,
+        git_max_retries: int = 3,
+        enable_log_rotation: bool = True
+    ):
+        """
+        Initialize the memory system.
+
+        Args:
+            repo_path: Path to the repository/dataset
+            git_timeout: Override default git operation timeout (seconds)
+            git_max_retries: Maximum retry attempts for git operations
+            enable_log_rotation: Whether to enable automatic log rotation
+        """
         # Determine paths
         self.base_path = repo_path
         # SURVIVAL: Align path with actual Dataset structure
@@ -22,26 +46,47 @@ class MemorySystem:
 
         self.memory_data: Dict[str, Any] = {}
         self.git: Optional[GitMemoryBridge] = None
+        self.log_manager: Optional[LogManager] = None
+        self.enable_log_rotation = enable_log_rotation
 
         # Initialize directories and load memory
         self._ensure_structure()
-        self._init_git()
+        self._init_git(git_timeout, git_max_retries)
+        self._init_log_manager()
         self.load_memory()
 
     def _ensure_structure(self):
         """Ensures the directory structure exists."""
         os.makedirs(os.path.dirname(self.memory_file), exist_ok=True)
 
-    def _init_git(self):
-        """Initialize Git repo connection if credentials are present."""
-        # GitMemoryBridge doesn't need user/token - it uses environment git config
+    def _init_git(self, timeout: int = None, max_retries: int = 3):
+        """Initialize Git repo connection with timeout and retry settings."""
         try:
-            self.git = GitMemoryBridge(repo_path=self.base_path)
-            print(f"🧠 [Memory] Git persistence enabled.")
+            self.git = GitMemoryBridge(
+                repo_path=self.base_path,
+                base_timeout=timeout,
+                max_retries=max_retries
+            )
+            logger.info("🧠 [Memory] Git persistence enabled.")
+            print(f"🧠 [Memory] Git persistence enabled (timeout: {timeout or 'default'}, retries: {max_retries}).")
         except Exception as e:
-            print(f"⚠️ [Memory] Failed to init Git: {e}")
+            logger.warning(f"Failed to init Git: {e}")
             print("🧠 [Memory] Running without Git persistence (ephemeral mode).")
 
+    def _init_log_manager(self):
+        """Initialize log manager for automatic cleanup."""
+        if self.enable_log_rotation:
+            try:
+                self.log_manager = LogManager()
+                # Add custom log paths if they exist
+                for log_path in ["/home/node/logs", "/app/logs", "/tmp/logs"]:
+                    if os.path.isdir(log_path):
+                        LogRetentionConfig.add_log_directory(log_path)
+                logger.info("🧠 [Memory] Log rotation enabled.")
+            except Exception as e:
+                logger.warning(f"Failed to init log manager: {e}")
+                self.log_manager = None
+
     def load_memory(self) -> Dict[str, Any]:
         """Loads memory from the JSON file."""
         if os.path.exists(self.memory_file):
@@ -77,23 +122,77 @@ class MemorySystem:
         }
 
     def save_memory(self) -> bool:
-        """Saves current memory state to file and optionally commits to Git."""
+        """
+        Saves current memory state to file and optionally commits to Git.
+
+        Includes proper error handling for git timeout and operation errors.
+        Performs periodic log rotation to prevent unbounded log growth.
+        """
         try:
             # Atomic write
             temp_path = self.memory_file + ".tmp"
             with open(temp_path, 'w', encoding='utf-8') as f:
                 json.dump(self.memory_data, f, indent=2)
             os.rename(temp_path, self.memory_file)
-            
+
             # Sync to Dataset if Git is available
             if self.git:
-                self.git.save_memory(f"Update memory state: {datetime.utcnow().isoformat()}")
-                
+                try:
+                    commit_msg = f"Update memory state: {datetime.utcnow().isoformat()}"
+                    if self.git.save_memory(commit_msg):
+                        logger.info("��� [Memory] Successfully saved to git.")
+                    else:
+                        logger.warning("⚠️ [Memory] Git save returned False (may be non-critical).")
+                except GitTimeoutError as e:
+                    logger.error(f"❌ [Memory] Git operation timed out: {e}")
+                    # Continue anyway - local save succeeded
+                except GitOperationError as e:
+                    logger.error(f"❌ [Memory] Git operation failed: {e}")
+                    # Continue anyway - local save succeeded
+                except Exception as e:
+                    logger.error(f"❌ [Memory] Unexpected git error: {e}")
+                    # Continue anyway - local save succeeded
+
+            # Periodic log rotation (every 10 saves)
+            self._maybe_rotate_logs()
+
             return True
+
         except Exception as e:
-            print(f"❌ [Memory] Failed to save: {e}")
+            logger.error(f"❌ [Memory] Failed to save memory: {e}")
             return False
 
+    def _maybe_rotate_logs(self):
+        """Perform log rotation periodically (every 10 calls)."""
+        if not self.log_manager:
+            return
+
+        # Use a counter stored in memory_data
+        save_count = self.memory_data.get("_save_count", 0)
+        save_count += 1
+        self.memory_data["_save_count"] = save_count
+
+        if save_count >= 10:
+            try:
+                logger.info("🧠 [Memory] Running periodic log rotation...")
+                stats = self.log_manager.rotate_all_logs()
+                logger.info(f"🧠 [Memory] Log rotation complete: {stats}")
+                self.memory_data["_save_count"] = 0
+            except Exception as e:
+                logger.warning(f"⚠️ [Memory] Log rotation failed (non-critical): {e}")
+
+    def get_log_health(self) -> Dict[str, Any]:
+        """Get health status of log directories."""
+        if self.log_manager:
+            return self.log_manager.get_log_health_status()
+        return {"status": "Log manager not initialized"}
+
+    def rotate_logs_now(self) -> Dict[str, Any]:
+        """Force immediate log rotation."""
+        if self.log_manager:
+            return self.log_manager.rotate_all_logs()
+        return {"error": "Log manager not initialized"}
+
     def get(self, key: str, default=None):
         """Retrieve a value from memory."""
         return self.memory_data.get(key, default)