Add docs to the logger

.gitignore

@@ -104,6 +104,3 @@ InitTestScene*.unity*
 .vscode/launch.json
 .vscode/settings.json
 .idea/.idea.AppleHillsProduction/.idea/indexLayout.xml
-
-# WIP docs
-/docs/wip/

Assets/Scripts/Bootstrap/BootSceneController.cs

@@ -30,6 +30,8 @@ namespace Bootstrap
         private float _sceneLoadingProgress = 0f;
         private LogVerbosity _logVerbosity = LogVerbosity.Warning;
 
+        // Run very early - need to set up loading screen before other systems initialize
+        public override int ManagedAwakePriority => 5;
 
         internal override void OnManagedAwake()
         {
@@ -81,8 +83,10 @@ namespace Bootstrap
             Invoke(nameof(StartLoadingMainMenu), minDelayAfterBoot);
         }
 
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Manual cleanup for events
             if (initialLoadingScreen != null)
             {

Assets/Scripts/Cinematics/CinematicsManager.cs

@@ -37,6 +37,8 @@ namespace Cinematics
         
         public PlayableDirector playableDirector;
         
+        public override int ManagedAwakePriority => 170; // Cinematic systems
+        
         internal override void OnManagedAwake()
         {
             // Set instance immediately (early initialization)

Assets/Scripts/Cinematics/SkipCinematic.cs

@@ -16,6 +16,8 @@ namespace Cinematics
         private bool _isHolding;
         private bool _skipPerformed;
     
+        public override int ManagedAwakePriority => 180; // Cinematic UI
+        
         internal override void OnManagedStart()
         {
             // Reset the progress bar
@@ -30,8 +32,10 @@ namespace Cinematics
             Logging.Debug("[SkipCinematic] Initialized");
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Clean up subscriptions
             UnsubscribeFromCinematicsEvents();
         }

Assets/Scripts/Core/GameManager.cs

@@ -34,6 +34,8 @@ namespace Core
         public event Action OnGamePaused;
         public event Action OnGameResumed;
 
+        // ManagedBehaviour configuration
+        public override int ManagedAwakePriority => 10; // Core infrastructure - runs early
 
         internal override void OnManagedAwake()
         {

Assets/Scripts/Core/ItemManager.cs

@@ -48,6 +48,8 @@ namespace Core
         // Args: first item data, second item data, result item data
         public event Action<PickupItemData, PickupItemData, PickupItemData> OnItemsCombined;
 
+        public override int ManagedAwakePriority => 75; // Item registry
+        
         internal override void OnManagedAwake()
         {
             // Set instance immediately (early initialization)
@@ -65,8 +67,10 @@ namespace Core
             ClearAllRegistrations();
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Ensure we clean up any subscriptions from registered items when the manager is destroyed
             ClearAllRegistrations();
         }

Assets/Scripts/Core/Lifecycle/LifecycleEnums.cs

@@ -6,19 +6,12 @@
     /// </summary>
     public enum LifecyclePhase
     {
-        /// <summary>
-        /// Called immediately during registration (during Awake).
-        /// Use for early initialization such as setting singleton instances.
-        /// NOT ordered - fires whenever Unity calls this component's Awake().
-        /// </summary>
-        ManagedAwake,
-        
         /// <summary>
         /// Called once per component after bootstrap completes.
         /// Guaranteed to be called after all bootstrap resources are loaded.
         /// For late-registered components, called immediately upon registration.
         /// </summary>
-        ManagedStart,
+        ManagedAwake,
         
         /// <summary>
         /// Called before a scene is unloaded.

Assets/Scripts/Core/Lifecycle/LifecycleManager.cs

@@ -59,11 +59,11 @@ namespace Core.Lifecycle
 
         #region State Flags
         
-        private bool isBootComplete;
+        private bool isBootComplete = false;
         private string currentSceneReady = "";
         
         // Scene loading state tracking
-        private bool isLoadingScene;
+        private bool isLoadingScene = false;
         private string sceneBeingLoaded = "";
         private List<ManagedBehaviour> pendingSceneComponents = new List<ManagedBehaviour>();
         
@@ -120,13 +120,17 @@ namespace Core.Lifecycle
             // Track which scene this component belongs to
             componentScenes[component] = sceneName;
 
-            // Add to all lifecycle lists (order of registration determines execution order)
+            // ALWAYS add to managedAwakeList - this is the master list used for save/load
-            managedAwakeList.Add(component);
+            InsertSorted(managedAwakeList, component, component.ManagedAwakePriority);
-            sceneUnloadingList.Add(component);
+
-            sceneReadyList.Add(component);
+            // Register for all scene lifecycle hooks
-            saveRequestedList.Add(component);
+            InsertSorted(sceneUnloadingList, component, component.SceneUnloadingPriority);
-            restoreRequestedList.Add(component);
+            InsertSorted(sceneReadyList, component, component.SceneReadyPriority);
-            destroyList.Add(component);
+            InsertSorted(saveRequestedList, component, component.SavePriority);
+            InsertSorted(restoreRequestedList, component, component.RestorePriority);
+            InsertSorted(destroyList, component, component.DestroyPriority);
+
+            // Call OnManagedAwake immediately after registration (early initialization hook)
             try
             {
                 component.OnManagedAwake();
@@ -142,7 +146,7 @@ namespace Core.Lifecycle
                 // Check if we're currently loading a scene
                 if (isLoadingScene && sceneName == sceneBeingLoaded)
                 {
-                    // Batch this component - will be processed when scene load completes
+                    // Batch this component - will be processed in priority order when scene load completes
                     pendingSceneComponents.Add(component);
                     LogDebug($"Batched component for scene load: {component.gameObject.name} (Scene: {sceneName})");
                 }
@@ -278,7 +282,10 @@ namespace Core.Lifecycle
 
             LogDebug($"Processing {pendingSceneComponents.Count} batched components for scene: {sceneBeingLoaded}");
 
-            // Call OnManagedStart in registration order
+            // Sort by ManagedAwake priority (lower values first)
+            pendingSceneComponents.Sort((a, b) => a.ManagedAwakePriority.CompareTo(b.ManagedAwakePriority));
+
+            // Call OnManagedStart in priority order
             foreach (var component in pendingSceneComponents)
             {
                 if (component == null) continue;
@@ -287,7 +294,7 @@ namespace Core.Lifecycle
                 {
                     component.OnManagedStart();
                     HandleAutoRegistrations(component);
-                    LogDebug($"Processed batched component: {component.gameObject.name}");
+                    LogDebug($"Processed batched component: {component.gameObject.name} (Priority: {component.ManagedAwakePriority})");
                 }
                 catch (Exception ex)
                 {
@@ -302,7 +309,7 @@ namespace Core.Lifecycle
         }
 
         /// <summary>
-        /// Broadcast OnSceneUnloading to components in the specified scene.
+        /// Broadcast OnSceneUnloading to components in the specified scene (reverse priority order).
         /// </summary>
         public void BroadcastSceneUnloading(string sceneName)
         {
@@ -329,8 +336,8 @@ namespace Core.Lifecycle
         }
 
         /// <summary>
-        /// Broadcast OnSceneReady to components in the specified scene.
+        /// Broadcast OnSceneReady to components in the specified scene (priority order).
-        /// Processes batched components first, then calls OnSceneReady on all components in that scene.
+        /// If scene loading mode is active, processes batched components first.
         /// </summary>
         public void BroadcastSceneReady(string sceneName)
         {
@@ -615,6 +622,42 @@ namespace Core.Lifecycle
 
         #region Helper Methods
         
+        /// <summary>
+        /// Insert component into list maintaining sorted order by priority.
+        /// Uses binary search for efficient insertion.
+        /// </summary>
+        private void InsertSorted(List<ManagedBehaviour> list, ManagedBehaviour component, int priority)
+        {
+            // Simple linear insertion for now (can optimize with binary search later if needed)
+            int index = 0;
+            for (int i = 0; i < list.Count; i++)
+            {
+                int existingPriority = GetPriorityForList(list[i], list);
+                if (priority < existingPriority)
+                {
+                    index = i;
+                    break;
+                }
+                index = i + 1;
+            }
+
+            list.Insert(index, component);
+        }
+
+        /// <summary>
+        /// Get the priority value for a component based on which list it's in.
+        /// </summary>
+        private int GetPriorityForList(ManagedBehaviour component, List<ManagedBehaviour> list)
+        {
+            if (list == managedAwakeList) return component.ManagedAwakePriority;
+            if (list == sceneUnloadingList) return component.SceneUnloadingPriority;
+            if (list == sceneReadyList) return component.SceneReadyPriority;
+            if (list == saveRequestedList) return component.SavePriority;
+            if (list == restoreRequestedList) return component.RestorePriority;
+            if (list == destroyList) return component.DestroyPriority;
+            return 100;
+        }
+
         /// <summary>
         /// Log debug message if debug logging is enabled.
         /// </summary>

Assets/Scripts/Core/Lifecycle/ManagedBehaviour.cs

@@ -8,6 +8,46 @@ namespace Core.Lifecycle
     /// </summary>
     public abstract class ManagedBehaviour : MonoBehaviour
     {
+        #region Priority Properties
+        
+        /// <summary>
+        /// Priority for OnManagedStart (lower values execute first).
+        /// Default: 100
+        /// </summary>
+        public virtual int ManagedAwakePriority => 100;
+        
+        /// <summary>
+        /// Priority for OnSceneUnloading (executed in reverse: higher values execute first).
+        /// Default: 100
+        /// </summary>
+        public virtual int SceneUnloadingPriority => 100;
+        
+        /// <summary>
+        /// Priority for OnSceneReady (lower values execute first).
+        /// Default: 100
+        /// </summary>
+        public virtual int SceneReadyPriority => 100;
+        
+        /// <summary>
+        /// Priority for OnSaveRequested (executed in reverse: higher values execute first).
+        /// Default: 100
+        /// </summary>
+        public virtual int SavePriority => 100;
+        
+        /// <summary>
+        /// Priority for OnRestoreRequested (lower values execute first).
+        /// Default: 100
+        /// </summary>
+        public virtual int RestorePriority => 100;
+        
+        /// <summary>
+        /// Priority for OnManagedDestroy (executed in reverse: higher values execute first).
+        /// Default: 100
+        /// </summary>
+        public virtual int DestroyPriority => 100;
+        
+        #endregion
+
         #region Configuration Properties
         
         /// <summary>
@@ -27,19 +67,14 @@ namespace Core.Lifecycle
         /// Unique identifier for this component in the save system.
         /// Default: "SceneName/GameObjectName/ComponentType"
         /// Override ONLY for special cases (e.g., singletons like "PlayerController", or custom IDs).
-        /// Cached on first access to avoid runtime allocation.
         /// </summary>
         public virtual string SaveId
         {
             get
-            {
-                if (_cachedSaveId == null)
             {
                 string sceneName = gameObject.scene.IsValid() ? gameObject.scene.name : "UnknownScene";
                 string componentType = GetType().Name;
-                    _cachedSaveId = $"{sceneName}/{gameObject.name}/{componentType}";
+                return $"{sceneName}/{gameObject.name}/{componentType}";
-                }
-                return _cachedSaveId;
             }
         }
         
@@ -48,7 +83,6 @@ namespace Core.Lifecycle
         #region Private Fields
         
         private bool _isRegistered;
-        private string _cachedSaveId;
         
         #endregion
 
@@ -73,16 +107,13 @@ namespace Core.Lifecycle
 
         /// <summary>
         /// Unity OnDestroy - automatically unregisters and cleans up.
-        /// SEALED: Cannot be overridden. Use OnManagedDestroy() for custom cleanup logic.
+        /// IMPORTANT: Derived classes that override OnDestroy MUST call base.OnDestroy()
         /// </summary>
-        private void OnDestroy()
+        protected virtual void OnDestroy()
         {
             if (!_isRegistered)
                 return;
 
-            // Call managed destroy hook
-            OnManagedDestroy();
-
             // Unregister from LifecycleManager
             if (LifecycleManager.Instance != null)
             {
@@ -118,7 +149,7 @@ namespace Core.Lifecycle
         /// <summary>
         /// Called once per component after bootstrap completes.
         /// GUARANTEE: Bootstrap resources are available, all managers are initialized.
-        /// For boot-time components: Called during LifecycleManager.BroadcastManagedStart (registration order).
+        /// For boot-time components: Called during LifecycleManager.BroadcastManagedStart (priority ordered).
         /// For late-registered components: Called immediately upon registration (bootstrap already complete).
         /// Use for initialization that depends on other systems.
         /// NOTE: Internal visibility allows LifecycleManager to call directly. Override in derived classes.
@@ -130,6 +161,7 @@ namespace Core.Lifecycle
 
         /// <summary>
         /// Called before the scene this component belongs to is unloaded.
+        /// Called in REVERSE priority order (higher values execute first).
         /// Use for scene-specific cleanup.
         /// NOTE: Internal visibility allows LifecycleManager to call directly. Override in derived classes.
         /// </summary>
@@ -140,6 +172,7 @@ namespace Core.Lifecycle
 
         /// <summary>
         /// Called after the scene this component belongs to has finished loading.
+        /// Called in priority order (lower values execute first).
         /// Use for scene-specific initialization.
         /// NOTE: Internal visibility allows LifecycleManager to call directly. Override in derived classes.
         /// </summary>
@@ -279,6 +312,7 @@ namespace Core.Lifecycle
 
         /// <summary>
         /// Called during OnDestroy before component is destroyed.
+        /// Called in REVERSE priority order (higher values execute first).
         /// NOTE: Most cleanup is automatic (managed events, auto-registrations).
         /// Only override if you need custom cleanup logic.
         /// Internal visibility allows LifecycleManager to call directly. Override in derived classes.

Assets/Scripts/Core/QuickAccess.cs

@@ -24,6 +24,9 @@ namespace AppleHills.Core
 
 		#endregion Singleton Setup
         
+        // Very early initialization - QuickAccess should be available immediately
+        public override int ManagedAwakePriority => 5;
+        
         #region Manager Instances
 
         // Core Managers

Assets/Scripts/Core/SaveLoad/SaveLoadManager.cs

@@ -43,6 +43,8 @@ namespace Core.SaveLoad
         public event Action<string> OnLoadCompleted;
         public event Action OnParticipantStatesRestored;
 
+        // ManagedBehaviour configuration
+        public override int ManagedAwakePriority => 20; // After GameManager and SceneManagerService
 
         internal override void OnManagedAwake()
         {
@@ -93,8 +95,10 @@ namespace Core.SaveLoad
 
         // ...existing code...
 
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy(); // Important: call base to unregister from LifecycleManager
+            
             if (_instance == this)
             {
                 _instance = null;

Assets/Scripts/Core/SaveablePlayableDirector.cs

@@ -42,8 +42,10 @@ namespace Core
             }
         }
 
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             if (_director != null)
             {
                 _director.stopped -= OnDirectorStopped;

Assets/Scripts/Core/SceneManagerService.cs

@@ -44,6 +44,8 @@ namespace Core
         private LogVerbosity _logVerbosity = LogVerbosity.Debug;
         private const string BootstrapSceneName = "BootstrapScene";
 
+        // ManagedBehaviour configuration
+        public override int ManagedAwakePriority => 15; // Core infrastructure, after GameManager
 
         internal override void OnManagedAwake()
         {
@@ -367,7 +369,7 @@ namespace Core
             await LoadSceneAsync(newSceneName, progress);
             CurrentGameplayScene = newSceneName;
             
-            // PHASE 10: Broadcast scene ready - processes batched components, then calls OnSceneReady
+            // PHASE 10: Broadcast scene ready - processes batched components in priority order, then calls OnSceneReady
             Logging.Debug($"Broadcasting OnSceneReady for: {newSceneName}");
             LifecycleManager.Instance?.BroadcastSceneReady(newSceneName);
             

Assets/Scripts/Core/SceneOrientationEnforcer.cs

@@ -18,6 +18,9 @@ namespace Core
         public GameObject orientationPromptPrefab;
         private LogVerbosity _logVerbosity = LogVerbosity.Warning;
 
+        // ManagedBehaviour configuration
+        public override int ManagedAwakePriority => 70; // Platform-specific utility
+
         internal override void OnManagedAwake()
         {
             // Set instance immediately (early initialization)
@@ -100,13 +103,15 @@ namespace Core
             }
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
             // Unsubscribe from events to prevent memory leaks
             if (SceneManagerService.Instance != null)
             {
                 SceneManagerService.Instance.SceneLoadCompleted -= OnSceneLoadCompleted;
             }
+            
+            base.OnDestroy(); // Important: call base
         }
         
         /// <summary>

Assets/Scripts/Data/CardSystem/CardSystemManager.cs

@@ -44,6 +44,8 @@ namespace Data.CardSystem
         public event Action<CardData> OnPendingCardAdded;
         public event Action<CardData> OnCardPlacedInAlbum;
 
+        public override int ManagedAwakePriority => 60; // Data systems
+        
         internal override void OnManagedAwake()
         {
             // Set instance immediately (early initialization)

Assets/Scripts/Dialogue/DialogueComponent.cs

@@ -32,6 +32,9 @@ namespace Dialogue
         public bool IsCompleted { get; private set; }
         public string CurrentSpeakerName => dialogueGraph?.speakerName;
         
+        
+        public override int ManagedAwakePriority => 150; // Dialogue systems
+        
         internal override void OnManagedStart()
         {
             // Get required components
@@ -181,8 +184,10 @@ namespace Dialogue
             return null;
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Unregister from events
             if (PuzzleManager.Instance != null)
                 PuzzleManager.Instance.OnStepCompleted -= OnAnyPuzzleStepCompleted;

Assets/Scripts/Input/InputManager.cs

@@ -50,6 +50,8 @@ namespace Input
         private bool isHoldActive;
         private LogVerbosity _logVerbosity = LogVerbosity.Warning;
 
+        public override int ManagedAwakePriority => 25; // Input infrastructure
+        
         internal override void OnManagedAwake()
         {
             // Set instance immediately (early initialization)
@@ -104,7 +106,7 @@ namespace Input
             SwitchInputOnSceneLoaded(sceneName);
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
             // Unsubscribe from SceneManagerService events
             if (SceneManagerService.Instance != null)
@@ -112,6 +114,7 @@ namespace Input
                 SceneManagerService.Instance.SceneLoadCompleted -= OnSceneLoadCompleted;
             }
             
+            base.OnDestroy();
             // Input action cleanup happens automatically
         }
 

Assets/Scripts/Input/PlayerTouchController.cs

@@ -70,6 +70,7 @@ namespace Input
         public override bool AutoRegisterForSave => true;
         // Scene-specific SaveId - each level has its own player state
         public override string SaveId => $"{gameObject.scene.name}/PlayerController";
+        public override int ManagedAwakePriority => 100; // Player controller
         
         internal override void OnManagedStart()
         {

Assets/Scripts/Interactions/Interactable.cs

@@ -41,6 +41,9 @@ namespace Interactions
         // Action component system
         private List<InteractionActionBase> _registeredActions = new List<InteractionActionBase>();
 
+        // ManagedBehaviour configuration
+        public override int ManagedAwakePriority => 100; // Gameplay base classes
+
 
         /// <summary>
         /// Register an action component with this interactable

Assets/Scripts/Interactions/ItemSlot.cs

@@ -287,8 +287,10 @@ namespace Interactions
             ItemManager.Instance?.RegisterItemSlot(this);
         }
 
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Unregister from slot manager
             ItemManager.Instance?.UnregisterItemSlot(this);
         }

Assets/Scripts/Interactions/Pickup.cs

@@ -50,8 +50,10 @@ namespace Interactions
             ItemManager.Instance?.RegisterPickup(this);
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Unregister from ItemManager
             ItemManager.Instance?.UnregisterPickup(this);
         }

Assets/Scripts/Levels/MinigameSwitch.cs

@@ -80,8 +80,10 @@ namespace Levels
             }
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             if (PuzzleManager.Instance != null)
             {
                 PuzzleManager.Instance.OnAllPuzzlesComplete -= HandleAllPuzzlesComplete;

Assets/Scripts/Minigames/DivingForPictures/DivingGameManager.cs

@@ -104,6 +104,7 @@ namespace Minigames.DivingForPictures
 
         public static DivingGameManager Instance => _instance;
 
+        public override int ManagedAwakePriority => 190;
         public override bool AutoRegisterPausable => true; // Automatic GameManager registration
 
         internal override void OnManagedAwake()
@@ -161,8 +162,10 @@ namespace Minigames.DivingForPictures
             }
         }
 
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy(); // Handles auto-unregister from GameManager
+            
             // Unsubscribe from events when the manager is destroyed
             PlayerCollisionBehavior.OnDamageTaken -= OnPlayerDamageTaken;
             OnMonsterSpawned -= DoMonsterSpawned;

Assets/Scripts/Movement/FollowerController.cs

@@ -106,6 +106,8 @@ public class FollowerController : ManagedBehaviour
     private bool _hasRestoredHeldItem; // Track if held item restoration completed
     private string _expectedHeldItemSaveId; // Expected saveId during restoration
     
+    public override int ManagedAwakePriority => 110; // Follower after player
+    
     internal override void OnManagedStart()
     {
         _aiPath = GetComponent<AIPath>();

Assets/Scripts/PuzzleS/ObjectiveStepBehaviour.cs

@@ -83,8 +83,10 @@ namespace PuzzleS
             }
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             if (PuzzleManager.Instance != null && stepData != null)
             {
                 PuzzleManager.Instance.UnregisterStepBehaviour(this);

Assets/Scripts/PuzzleS/PuzzleManager.cs

@@ -94,6 +94,8 @@ namespace PuzzleS
         // Track pending unlocks for steps that were unlocked before their behavior registered
         private HashSet<string> _pendingUnlocks = new HashSet<string>();
 
+        public override int ManagedAwakePriority => 80; // Puzzle systems
+        
         internal override void OnManagedAwake()
         {
             // Set instance immediately (early initialization)
@@ -136,8 +138,10 @@ namespace PuzzleS
             LoadPuzzlesForScene(sceneName);
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Unsubscribe from SceneManagerService events
             if (SceneManagerService.Instance != null)
             {

Assets/Scripts/Sound/AudioManager.cs

@@ -40,6 +40,8 @@ public class AudioManager : ManagedBehaviour, IPausable
     /// </summary>
     public static AudioManager Instance => _instance;
 
+    // ManagedBehaviour configuration
+    public override int ManagedAwakePriority => 30; // Audio infrastructure
     public override bool AutoRegisterPausable => true; // Auto-register as IPausable
 
     internal override void OnManagedAwake()

Assets/Scripts/UI/AppSwitcher.cs

@@ -110,8 +110,10 @@ public class AppSwitcher : UIPage
         );
     }
     
-    internal override void OnManagedDestroy()
+    protected override void OnDestroy()
     {
+        base.OnDestroy();
+        
         // Clean up tweens
         slideInTween?.Stop();
         slideOutTween?.Stop();

Assets/Scripts/UI/CardSystem/AlbumViewPage.cs

@@ -149,7 +149,7 @@ namespace UI.CardSystem
             }
         }
 
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
             // Unsubscribe from CardSystemManager
             if (CardSystemManager.Instance != null)
@@ -181,6 +181,9 @@ namespace UI.CardSystem
             
             // Clean up active cards
             CleanupActiveCards();
+            
+            // Call base implementation
+            base.OnDestroy();
         }
 
         private void OnExitButtonClicked()

Assets/Scripts/UI/CardSystem/BoosterNotificationDot.cs

@@ -70,13 +70,16 @@ namespace UI.CardSystem
             }
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
             // Unsubscribe from CardSystemManager events to prevent memory leaks
             if (CardSystemManager.Instance != null)
             {
                 CardSystemManager.Instance.OnBoosterCountChanged -= OnBoosterCountChanged;
             }
+            
+            // Call base implementation
+            base.OnDestroy();
         }
         
         /// <summary>

Assets/Scripts/UI/CardSystem/BoosterOpeningPage.cs

@@ -76,8 +76,10 @@ namespace UI.CardSystem
             gameObject.SetActive(false);
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Unsubscribe from dismiss button
             if (_dismissButton != null)
             {

Assets/Scripts/UI/CardSystem/DragDrop/BoosterPackVisual.cs

@@ -308,8 +308,10 @@ namespace UI.CardSystem.DragDrop
         
         #endregion
         
-        private void OnDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             if (_boosterDraggable != null)
             {
                 _boosterDraggable.OnBoosterOpened -= HandleBoosterOpened;

Assets/Scripts/UI/CardSystem/DragDrop/CardDraggableVisual.cs

@@ -107,8 +107,10 @@ namespace UI.CardSystem.DragDrop
             // Card-specific visual effects when dragging ends
         }
         
-        private void OnDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             if (_cardDraggable != null)
             {
                 _cardDraggable.OnCardDataChanged -= HandleCardDataChanged;

Assets/Scripts/UI/Core/UIPage.cs

@@ -15,6 +15,9 @@ namespace UI.Core
         [Header("Page Settings")]
         public string PageName;
         
+        // UI pages load after UI infrastructure (UIPageController is priority 50)
+        public override int ManagedAwakePriority => 200;
+        
         // Events using System.Action instead of UnityEvents
         public event Action OnTransitionInStarted;
         public event Action OnTransitionInCompleted;

Assets/Scripts/UI/Core/UIPageController.cs

@@ -37,6 +37,8 @@ namespace UI.Core
         private PlayerInput _playerInput;
         private InputAction _cancelAction;
         
+        public override int ManagedAwakePriority => 50; // UI infrastructure
+        
         internal override void OnManagedAwake()
         {
             // Set instance immediately (early initialization)
@@ -48,8 +50,10 @@ namespace UI.Core
             Logging.Debug("[UIPageController] Initialized");
         }
         
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Clean up cached instances
             foreach (var cachedPage in _prefabInstanceCache.Values)
             {

Assets/Scripts/UI/LoadingScreenController.cs

@@ -53,6 +53,9 @@ namespace UI
         /// </summary>
         public static LoadingScreenController Instance => _instance;
         
+        // ManagedBehaviour configuration
+        public override int ManagedAwakePriority => 45; // UI infrastructure, before UIPageController
+
         internal override void OnManagedAwake()
         {
             // Set instance immediately (early initialization)

Assets/Scripts/UI/PauseMenu.cs

@@ -28,6 +28,9 @@ namespace UI
         [SerializeField] private GameObject mainOptionsContainer;
         [SerializeField] private GameObject devOptionsContainer;
 
+        // After UIPageController (50)
+        public override int ManagedAwakePriority => 55;
+        
         internal override void OnManagedAwake()
         {
             // Set instance immediately (early initialization)
@@ -73,8 +76,10 @@ namespace UI
             // This only fires once for DontDestroyOnLoad objects, so we handle scene loads in OnManagedAwake
         }
 
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Unsubscribe when destroyed
             if (SceneManagerService.Instance != null)
             {

Assets/Scripts/UI/PlayerHudManager.cs

@@ -172,8 +172,10 @@ namespace UI
             }
         }
 
-        internal override void OnManagedDestroy()
+        protected override void OnDestroy()
         {
+            base.OnDestroy();
+            
             // Unsubscribe from events
             if (_uiPageController != null)
             {

Assets/Scripts/UI/Tutorial/DivingTutorial.cs

@@ -30,6 +30,7 @@ namespace UI.Tutorial
         private bool _canAcceptInput;
         private Coroutine _waitLoopCoroutine;
 
+        public override int ManagedAwakePriority => 200; // Tutorial runs late, after other systems
 
         internal override void OnManagedStart()
         {

docs/managed_behavior/architecture_overview.md

@@ -1,93 +0,0 @@
-# ManagedBehaviour System - Architecture Overview
-
-**Version:** 2.0 <br>
-**Updated:** 11.11.2025
-
-
----
-
-## What is the ManagedBehaviour System?
-
-Lifecycle orchestration framework that provides guaranteed execution order and deterministic lifecycle management for Unity components.
-
-### Problems Solved
-
-We've had quite a few things shoe-stringed together in various ways and dependant on references to each other.
-Due to undefined initialization order - null references during access to yet uninitialized resources was becoming a problem.
-
-### What You Get
-
-- **Guaranteed Initialization Order** - Managers ready before components that depend on them
-- **Deterministic Lifecycle Hooks** - Predictable callbacks at key moments
-- **Automatic Registration** - No boilerplate for wiring up systems
-- **Scene Lifecycle Events** - Built-in hooks for scene load/unload
-- **Save/Load Coordination** - Centralized collection of save data
-- **Bootstrap Integration** - Components know when bootstrap completes  
-
----
-
-## Architecture Principles
-
-### 1. Centralized Orchestration
-
-Single `LifecycleManager` singleton coordinates all lifecycle events. Components auto-register and receive callbacks at appropriate times.
-
-### 2. Sealed Framework Methods
-
-`Awake()` and `OnDestroy()` are sealed. Use `OnManagedAwake()` and `OnManagedDestroy()` instead. Prevents forgetting to call `base.Awake()`.
-
-### 3. Two-Phase Initialization
-
-- **Early (`OnManagedAwake()`)**: During Unity's Awake, before bootstrap. Use for singleton setup.
-- **Late (`OnManagedStart()`)**: After bootstrap completes. All managers guaranteed ready.
-
-### 4. Registration Order Execution
-
-Execution follows Unity's natural Awake order. No priority numbers to manage.
-
-### 5. Automatic Cleanup
-
-Framework handles unregistration automatically. Override `OnManagedDestroy()` only if you need custom cleanup.
-
----
-
-## Lifecycle Flow Diagrams
-
-### Boot Sequence
-
-![Boot Sequence](../media/boot_sequence.png)
-
-### Scene Transition Flow
-
-![Scene Transition Flow](../media/scene_transition_flow.png)
-
-### Component Lifecycle (Individual Component)
-
-![Component Lifecycle](../media/component_lifecycle.png)
-
----
-
-## Class Diagram
-
-![Class Diagram](../media/class_diagram.png)
-
----
-## Key Guarantees
-
-### Guaranteed
-
-1. **Bootstrap Completion** - `OnManagedStart()` always fires after bootstrap completes
-2. **Manager Availability** - All manager singletons exist when `OnManagedStart()` is called
-3. **Scene Lifecycle** - `OnSceneReady()` fires after scene load, `OnSceneUnloading()` before unload
-4. **Automatic Registration** - Can't forget to register (Awake is sealed)
-5. **Automatic Cleanup** - Can't forget to unregister (OnDestroy is sealed)
-6. **Save/Load Coordination** - All save participants called in one pass
-
-### Not Guaranteed
-
-1. **Initialization Order Between Components** - `OnManagedAwake()` follows Unity's unpredictable Awake order
-2. **Thread Safety** - All methods must run on main thread
-3. **Performance** - Broadcasting to 1000+ components may have overhead
-4. **SaveId Uniqueness** - Developer responsible for unique SaveIds
-
-

docs/managed_behavior/technical_reference.md

@@ -1,377 +0,0 @@
-# ManagedBehaviour System - Technical Reference
-
-**Version:** 2.0 <br>
-**Updated:** 11.11.2025
-
----
-
-## Overview
-
-The ManagedBehaviour system provides a deterministic, ordered lifecycle management framework for Unity MonoBehaviours. This document provides complete technical documentation of all classes, methods, and APIs.
-
----
-
-## Core Classes
-
-### ManagedBehaviour (Abstract Base Class)
-
-**Namespace:** `Core.Lifecycle`  
-**Inherits:** `MonoBehaviour`  
-**Location:** `Assets/Scripts/Core/Lifecycle/ManagedBehaviour.cs` → [View Source](../../Assets/Scripts/Core/Lifecycle/ManagedBehaviour.cs)
-
-Abstract base class that all managed components must inherit from. Provides automatic registration with LifecycleManager and ordered lifecycle callbacks.
-
-#### Lifecycle Hook Methods
-
-Override these `internal virtual` methods to customize component behavior at different lifecycle stages. Called automatically by `LifecycleManager`.
-
-<details>
-<summary>Click to see more details</summary>
-
-##### `OnManagedAwake()`
-```csharp
-internal virtual void OnManagedAwake()
-```
-**Called:** During registration (within Unity's Awake phase)  
-**Execution Order:** Natural Unity script execution order (not guaranteed between components)  
-**Use For:**
-- Setting singleton instances (`_instance = this`)
-- Early GetComponent calls
-- One-time initialization that doesn't depend on other systems
-
-**Timing Guarantees:**
-- ✅ GameObject and component exist
-- ✅ Scene is loaded
-- ❌ Other components may not be initialized yet
-- ❌ Bootstrap may not be complete
-
-##### `OnManagedStart()`
-```csharp
-internal virtual void OnManagedStart()
-```
-**Called:** After bootstrap completes (for boot components) or immediately after registration (for late-registered components)  
-**Execution Order:** Registration order  
-**Use For:**
-- Initialization that depends on other managers
-- Accessing singleton instances safely
-- Setting up cross-system dependencies
-
-**Timing Guarantees:**
-- ✅ All managers are initialized
-- ✅ Bootstrap resources are available
-- ✅ Safe to access `GameManager.Instance`, `AudioManager.Instance`, etc.
-
-##### `OnSceneUnloading()`
-```csharp
-internal virtual void OnSceneUnloading()
-```
-**Called:** Before scene unload  
-**Execution Order:** Registration order  
-**Use For:**
-- Scene-specific cleanup
-- Saving temporary scene state
-
-**Timing Guarantees:**
-- ✅ Scene is still loaded
-- ✅ Other components in scene still exist
-
-##### `OnSceneReady()`
-```csharp
-internal virtual void OnSceneReady()
-```
-**Called:** After scene load completes  
-**Execution Order:** Registration order  
-**Use For:**
-- Scene-specific initialization
-- Finding scene objects
-- Setting up scene-specific state
-
-**Timing Guarantees:**
-- ✅ All scene GameObjects are loaded
-- ✅ Batched components have received `OnManagedStart()`
-
-##### `OnSceneSaveRequested()`
-```csharp
-internal virtual string OnSceneSaveRequested()
-```
-**Called:** Before scene unload during scene transitions  
-**Returns:** Serialized scene-specific data (JSON string), or `null` if nothing to save  
-**Use For:**
-- Level progress
-- Object positions
-- Puzzle states
-- Temporary scene data
-
-**⚠️ Important:** Must return synchronously.
-
-##### `OnSceneRestoreRequested(string serializedData)`
-```csharp
-internal virtual void OnSceneRestoreRequested(string serializedData)
-```
-**Called:** After scene load, during `OnSceneReady` phase  
-**Parameters:**
-- `serializedData` - Previously saved data from `OnSceneSaveRequested()`
-
-**Use For:**
-- Restoring level progress
-- Setting object positions
-- Restoring puzzle states
-
-**⚠️ Important:** Must execute synchronously. Do not use coroutines or async/await.
-
-##### `OnSceneRestoreCompleted()`
-```csharp
-internal virtual void OnSceneRestoreCompleted()
-```
-**Called:** After all `OnSceneRestoreRequested()` calls complete  
-**Timing:** Always called after scene load, whether save data exists or not  
-**Use For:**
-- Post-restore initialization
-- First-time initialization (when no save data exists)
-- Triggering events after state is restored
-
-**Common Pattern:**
-```csharp
-internal override void OnSceneRestoreCompleted()
-{
-    if (!_hasPlayed) // Check if this is first time
-    {
-        PlayIntroAudio();
-        _hasPlayed = true;
-    }
-}
-```
-
-##### `OnGlobalSaveRequested()`
-```csharp
-internal virtual string OnGlobalSaveRequested()
-```
-**Called:** Once before save file is written to disk  
-**Returns:** Serialized global persistent data (JSON string), or `null`  
-**Use For:**
-- Player inventory
-- Unlocked features
-- Card collections
-- Persistent progression
-
-**Timing:** Called once per game save (not per scene transition)
-
-##### `OnGlobalRestoreRequested(string serializedData)`
-```csharp
-internal virtual void OnGlobalRestoreRequested(string serializedData)
-```
-**Called:** Once on game boot after save file is read  
-**Parameters:**
-- `serializedData` - Previously saved data from `OnGlobalSaveRequested()`
-
-**Use For:**
-- Restoring player inventory
-- Restoring unlocked features
-- Restoring persistent progression
-
-**Timing:** Called once on boot, not during scene transitions
-
-##### `OnGlobalLoadCompleted()`
-```csharp
-internal virtual void OnGlobalLoadCompleted()
-```
-**Called:** Once on game boot after all global restore operations complete  
-**Use For:**
-- Triggering UI updates after load
-- Broadcasting load events
-- Post-load initialization
-
-##### `OnGlobalSaveStarted()`
-```csharp
-internal virtual void OnGlobalSaveStarted()
-```
-**Called:** Once before save file is written  
-**Use For:**
-- Final validation before save
-- Cleanup operations before save
-
-##### `OnManagedDestroy()`
-```csharp
-internal virtual void OnManagedDestroy()
-```
-**Called:** During `OnDestroy`, before unregistration  
-**Execution Order:** Registration order  
-**Use For:**
-- Unsubscribing from events
-- Releasing resources
-- Custom cleanup logic
-
-**Note:** Most cleanup is automatic (auto-registrations are handled by framework).
-</details>
-
-#### Configuration Properties
-
-Virtual properties that control automatic behaviors like pause registration and save system participation.
-
-<details>
-<summary>Click to see more details</summary>
-
-##### `AutoRegisterPausable`
-```csharp
-public virtual bool AutoRegisterPausable => false;
-```
-**Type:** `bool`  
-**Default:** `false`  
-**Description:** If true and component implements `IPausable`, automatically registers with `GameManager.Instance` during initialization. Automatic unregistration occurs on destruction.
-
-##### `AutoRegisterForSave`
-```csharp
-public virtual bool AutoRegisterForSave => false;
-```
-**Type:** `bool`  
-**Default:** `false`  
-**Description:** If true, component participates in the save/load system. Should override `OnSceneSaveRequested()` and `OnSceneRestoreRequested()` or global equivalents.
-
-##### `SaveId`
-```csharp
-public virtual string SaveId { get; }
-```
-**Type:** `string`  
-**Default:** `"{SceneName}/{GameObjectName}/{ComponentType}"`  
-**Description:** Unique identifier for this component in the save system. Cached on first access for performance. Override for singletons (e.g., `"PlayerController"`) or custom IDs.
-
-**⚠️ Warning:** GameObject name changes at runtime will NOT update the cached SaveId.
-</details>
-
-### Private Lifecycle Methods
-<details>
-<summary>Click to see more details</summary>
-
-##### `Awake()`
-```csharp
-private void Awake()
-```
-**Visibility:** `private` (sealed, cannot be overridden)
-**Called By:** Unity
-**Description:** Automatically registers component with `LifecycleManager`. Calls `OnManagedAwake()` during registration.
-
-**⚠️ Important:** This method is sealed. Use `OnManagedAwake()` for early initialization.
-
-##### `OnDestroy()`
-```csharp
-private void OnDestroy()
-```
-**Visibility:** `private` (sealed, cannot be overridden)
-**Called By:** Unity
-**Description:** Calls `OnManagedDestroy()`, unregisters from `LifecycleManager`, and handles auto-unregistrations.
-
-**⚠️ Important:** This method is sealed. Use `OnManagedDestroy()` for custom cleanup.
-</details>
-
----
-
-## LifecycleManager (Singleton Orchestrator)
-
-**Namespace:** `Core.Lifecycle`  
-**Inherits:** `MonoBehaviour`  
-**Location:** `Assets/Scripts/Core/Lifecycle/LifecycleManager.cs` → [View Source](../../Assets/Scripts/Core/Lifecycle/LifecycleManager.cs)
-
-Central orchestrator that manages all `ManagedBehaviour` components and broadcasts lifecycle events.
-
-### Static Properties
-
-##### `Instance`
-Singleton instance. Created automatically by `CustomBoot` before bootstrap begins.
-
-### Public Methods
-
-Core methods for registration, lifecycle broadcasting, and save/restore operations. Most are called automatically by the framework.
-
-<details>
-<summary>Click to see more details</summary>
-
-##### `Register(ManagedBehaviour component)`
-```csharp
-public void Register(ManagedBehaviour component)
-```
-Registers a component with the lifecycle system. **Called automatically from `ManagedBehaviour.Awake()`.**
-
-##### `Unregister(ManagedBehaviour component)`
-```csharp
-public void Unregister(ManagedBehaviour component)
-```
-Unregisters a component. **Called automatically from `ManagedBehaviour.OnDestroy()`.**
-
-##### `OnBootCompletionTriggered()`
-```csharp
-public void OnBootCompletionTriggered()
-```
-Called by `CustomBoot` after bootstrap completes. Broadcasts `OnManagedStart()` to all registered components.
-
-##### `BeginSceneLoad(string sceneName)`
-```csharp
-public void BeginSceneLoad(string sceneName)
-```
-Activates scene loading batching mode. Called by `SceneManagerService` when loading a scene.
-
-##### `BroadcastSceneReady(string sceneName)`
-```csharp
-public void BroadcastSceneReady(string sceneName)
-```
-Processes batched components and broadcasts `OnSceneReady()` to all components in the scene. Called by `SceneManagerService` after scene load.
-
-##### `BroadcastSceneUnloading(string sceneName)`
-```csharp
-public void BroadcastSceneUnloading(string sceneName)
-```
-Broadcasts `OnSceneUnloading()` to all components in the specified scene. Called by `SceneManagerService` before scene unload.
-
-##### `BroadcastSceneSaveRequested()`
-```csharp
-public Dictionary<string, string> BroadcastSceneSaveRequested()
-```
-Broadcasts `OnSceneSaveRequested()` to all components with `AutoRegisterForSave == true`. Returns dictionary of SaveId → serialized data.
-
-##### `BroadcastSceneRestoreRequested(Dictionary<string, string> saveData)`
-```csharp
-public void BroadcastSceneRestoreRequested(Dictionary<string, string> saveData)
-```
-Distributes save data to components by matching `SaveId`, then broadcasts `OnSceneRestoreCompleted()`.
-
-##### `BroadcastGlobalSaveRequested()`
-```csharp
-public Dictionary<string, string> BroadcastGlobalSaveRequested()
-```
-Broadcasts `OnGlobalSaveRequested()` to all components with `AutoRegisterForSave == true`. Returns dictionary of SaveId → serialized data.
-
-##### `BroadcastGlobalRestoreRequested(Dictionary<string, string> saveData)`
-```csharp
-public void BroadcastGlobalRestoreRequested(Dictionary<string, string> saveData)
-```
-Distributes save data to components by matching `SaveId`, then broadcasts `OnGlobalLoadCompleted()`.
-
-##### `BroadcastGlobalSaveStarted()`
-```csharp
-public void BroadcastGlobalSaveStarted()
-```
-Broadcasts `OnGlobalSaveStarted()` to all components with `AutoRegisterForSave == true`.
-
-## LifecyclePhase (Enum)
-
-**Namespace:** `Core.Lifecycle`  
-**Location:** `Assets/Scripts/Core/Lifecycle/LifecycleEnums.cs` → [View Source](../../Assets/Scripts/Core/Lifecycle/LifecycleEnums.cs)
-
-Defines the different lifecycle phases for documentation and tooling purposes.
-
-```csharp
-public enum LifecyclePhase
-{
-    ManagedAwake,       // During registration (Awake)
-    ManagedStart,       // After bootstrap or late registration
-    SceneUnloading,     // Before scene unload
-    SceneReady,         // After scene load
-    SaveRequested,      // Before scene unload (save)
-    RestoreRequested,   // After scene load (restore)
-    ManagedDestroy      // During OnDestroy
-}
-```
-
----
-
-
-

docs/managed_behavior/use_cases_quick_start.md

@@ -1,522 +0,0 @@
-# ManagedBehaviour System - Quick Start & Use Cases
-
-**TL;DR:** Inherit from `ManagedBehaviour` instead of `MonoBehaviour`. Override lifecycle hooks instead of Awake/OnDestroy. Get guaranteed initialization order and automatic registration.
-
----
-
-## Table of Contents
-
-1. [Lifecycle Methods Summary](#lifecycle-methods-summary)
-2. [Quick Reference - Common Use Cases](#quick-reference---common-use-cases)
-3. [Getting Started Examples](#getting-started-examples)
-4. [Detailed Use Cases](#detailed-use-cases)
-5. [Common Patterns](#common-patterns)
-6. [Migration Checklist](#migration-checklist)
-7. [Troubleshooting](#troubleshooting)
-8. [Best Practices](#best-practices)
-9. [FAQ](#faq)
-
----
-
-## Summary
-
-**ManagedBehaviour in 3 Sentences:**
-
-Inherit from `ManagedBehaviour` to get automatic lifecycle management with guaranteed initialization order. Use `OnManagedStart()` to safely access manager singletons, and use built-in save/load hooks for persistence. The framework handles registration and cleanup automatically - you just override the hooks you need.
-
-**When to Use:**
-- ✅ Singleton managers
-- ✅ Components that access managers
-- ✅ Components that need save/load
-- ✅ Components that need scene lifecycle events
-
-**When to Skip:**
-- ❌ Simple self-contained components
-- ❌ Third-party code (can't change base class)
-- ❌ Performance-critical code with no dependencies
-
-**But can I still use regular MonoBehaviour?!** <br>
-_Yes!_ Only use ManagedBehaviour when you need its features (manager access, save/load, etc.)
-
-
----
-
-## Lifecycle Methods Summary
-
-1. **OnManagedAwake()** - Called during Unity's Awake phase; use for **internal setup** and GetComponent calls.
-2. **OnManagedStart()** - Called after bootstrap completes; **safe to access** manager singletons.
-3. **OnSceneReady()** - Called after scene finishes loading; use for scene-specific initialization.
-4. **OnSceneUnloading()** - Called before scene unloads; use for scene cleanup.
-5. **OnSceneSaveRequested()** - Returns serialized scene-specific data before scene transitions.
-6. **OnSceneRestoreRequested(data)** - Receives saved scene data after scene loads.
-7. **OnSceneRestoreCompleted()** - Called after all scene restore operations complete.
-8. **OnGlobalSaveRequested()** - Returns serialized persistent data when game saves.
-9. **OnGlobalRestoreRequested(data)** - Receives persistent data on game boot.
-10. **OnGlobalLoadCompleted()** - Called after all global restore operations complete on boot.
-11. **OnGlobalSaveStarted()** - Called before save file is written; use for pre-save validation.
-12. **OnManagedDestroy()** - Called during OnDestroy; use for cleanup and event unsubscription.
-
----
-
-## Quick Reference - Common Use Cases
-
-### Access Manager Singleton Safely
-```csharp
-internal override void OnManagedStart()
-{
-    GameManager.Instance.DoSomething(); // Safe - managers guaranteed ready
-}
-```
-
-### Create Singleton Manager
-```csharp
-private static MyManager _instance;
-public static MyManager Instance => _instance;
-
-internal override void OnManagedAwake()
-{
-    _instance = this;
-}
-```
-
-### Save Scene Progress
-```csharp
-public override bool AutoRegisterForSave => true;
-
-internal override string OnSceneSaveRequested()
-{
-    return JsonUtility.ToJson(myData);
-}
-
-internal override void OnSceneRestoreRequested(string data)
-{
-    myData = JsonUtility.FromJson<MyData>(data);
-}
-```
-
-### Auto-Register as Pausable
-```csharp
-public class MyComponent : ManagedBehaviour, IPausable
-{
-    public override bool AutoRegisterPausable => true;
-    
-    public void Pause() { /* pause logic */ }
-    public void Resume() { /* resume logic */ }
-}
-```
-
-### Scene-Specific Initialization
-```csharp
-internal override void OnSceneReady()
-{
-    FindObjectsInScene();
-    InitializeLevel();
-}
-```
-
-### Cleanup on Destroy
-```csharp
-internal override void OnManagedDestroy()
-{
-    EventBus.OnSomething -= HandleEvent;
-}
-```
-
----
-
-## Getting Started Examples
-
-### 1. Basic Component
-
-```csharp
-using Core.Lifecycle;
-
-public class MyComponent : ManagedBehaviour
-{
-    internal override void OnManagedAwake()
-    {
-        // Early initialization (singleton setup, GetComponent)
-        Debug.Log("MyComponent awakened");
-    }
-
-    internal override void OnManagedStart()
-    {
-        // Late initialization (safe to access managers)
-        Debug.Log("MyComponent started - managers are ready");
-    }
-}
-```
-
-### 2. Singleton Manager
-
-```csharp
-using Core.Lifecycle;
-
-public class MyManager : ManagedBehaviour
-{
-    private static MyManager _instance;
-    public static MyManager Instance => _instance;
-
-    internal override void OnManagedAwake()
-    {
-        _instance = this; // Set singleton early
-    }
-
-    internal override void OnManagedStart()
-    {
-        // All other managers are ready here
-        AudioManager.Instance.PlaySound("ManagerReady");
-    }
-}
-```
-
-### 3. Component with Save/Load
-
-```csharp
-using Core.Lifecycle;
-
-public class PuzzleComponent : ManagedBehaviour
-{
-    public override bool AutoRegisterForSave => true;
-    public override string SaveId => "MyPuzzle"; // Custom ID
-    
-    private bool _isSolved;
-
-    internal override string OnSceneSaveRequested()
-    {
-        return JsonUtility.ToJson(new { isSolved = _isSolved });
-    }
-
-    internal override void OnSceneRestoreRequested(string data)
-    {
-        var saveData = JsonUtility.FromJson<SaveData>(data);
-        _isSolved = saveData.isSolved;
-    }
-
-    [System.Serializable]
-    private class SaveData
-    {
-        public bool isSolved;
-    }
-}
-```
-
-### 4. Component with Cleanup
-
-```csharp
-using Core.Lifecycle;
-
-public class EventSubscriber : ManagedBehaviour
-{
-    internal override void OnManagedStart()
-    {
-        GameManager.Instance.OnGamePaused += HandlePause;
-    }
-
-    internal override void OnManagedDestroy()
-    {
-        // Automatic cleanup
-        if (GameManager.Instance != null)
-            GameManager.Instance.OnGamePaused -= HandlePause;
-    }
-
-    private void HandlePause() { }
-}
-```
-
----
-
-## Detailed Use Cases
-
-### Use Case 1: Accessing Singleton Managers Safely
-
-**Problem:** Accessing `GameManager.Instance` in `Awake()` might fail if GameManager hasn't initialized yet.
-
-**Solution:**
-```csharp
-public class Player : ManagedBehaviour
-{
-    // ❌ DON'T: Risky in OnManagedAwake (managers may not be ready)
-    internal override void OnManagedAwake()
-    {
-        // var settings = GameManager.Instance.GetSettings(); // RISKY!
-    }
-
-    // ✅ DO: Safe in OnManagedStart (managers guaranteed ready)
-    internal override void OnManagedStart()
-    {
-        var settings = GameManager.Instance.GetSettings(); // SAFE!
-        ApplySettings(settings);
-    }
-}
-```
-
----
-
-### Use Case 2: Scene-Specific Initialization
-
-**Problem:** Need to initialize something after a scene finishes loading.
-
-**Solution:**
-```csharp
-public class LevelManager : ManagedBehaviour
-{
-    internal override void OnSceneReady()
-    {
-        // Scene is fully loaded, all objects exist
-        FindObjectiveMarkers();
-        SpawnEnemies();
-        PlayLevelMusic();
-    }
-}
-```
-
----
-
-### Use Case 3: Saving Player Progress
-
-**Problem:** Need to save level progress when transitioning between scenes.
-
-**Solution:**
-```csharp
-public class LevelProgress : ManagedBehaviour
-{
-    public override bool AutoRegisterForSave => true;
-    public override string SaveId => "LevelProgress";
-    
-    private int _checkpointIndex;
-    private float _timeElapsed;
-
-    internal override string OnSceneSaveRequested()
-    {
-        return JsonUtility.ToJson(new 
-        { 
-            checkpoint = _checkpointIndex,
-            time = _timeElapsed 
-        });
-    }
-
-    internal override void OnSceneRestoreRequested(string data)
-    {
-        var save = JsonUtility.FromJson<SaveData>(data);
-        _checkpointIndex = save.checkpoint;
-        _timeElapsed = save.time;
-    }
-
-    internal override void OnSceneRestoreCompleted()
-    {
-        // Restore complete, trigger UI update
-        UpdateProgressUI();
-    }
-}
-```
-
----
-
-### Use Case 4: Global Persistent Data (Inventory)
-
-**Problem:** Need to save player inventory across all scenes.
-
-**Solution:**
-```csharp
-public class InventoryManager : ManagedBehaviour
-{
-    public override bool AutoRegisterForSave => true;
-    public override string SaveId => "Inventory";
-    
-    private List<string> _items = new List<string>();
-
-    internal override string OnGlobalSaveRequested()
-    {
-        // Save to global save file (not scene-specific)
-        return JsonUtility.ToJson(new { items = _items });
-    }
-
-    internal override void OnGlobalRestoreRequested(string data)
-    {
-        // Restore from global save file on boot
-        var save = JsonUtility.FromJson<SaveData>(data);
-        _items = new List<string>(save.items);
-    }
-
-    internal override void OnGlobalLoadCompleted()
-    {
-        // All global data loaded, safe to initialize UI
-        RefreshInventoryUI();
-    }
-}
-```
-
----
-
-### Use Case 5: Auto-Registering as Pausable
-
-**Problem:** Component implements `IPausable` and needs to register with `GameManager`.
-
-**Solution:**
-```csharp
-public class AnimatedCharacter : ManagedBehaviour, IPausable
-{
-    public override bool AutoRegisterPausable => true;
-    
-    // IPausable implementation
-    public void Pause()
-    {
-        // Pause animations
-    }
-
-    public void Resume()
-    {
-        // Resume animations
-    }
-}
-// No manual registration needed - automatic!
-```
-
----
-
-### Use Case 6: Scene Cleanup
-
-**Problem:** Need to clean up scene-specific state before transitioning.
-
-**Solution:**
-```csharp
-public class ParticleSpawner : ManagedBehaviour
-{
-    private List<GameObject> _activeParticles = new List<GameObject>();
-
-    internal override void OnSceneUnloading()
-    {
-        // Clean up before scene unloads
-        foreach (var particle in _activeParticles)
-        {
-            if (particle != null)
-                Destroy(particle);
-        }
-        _activeParticles.Clear();
-    }
-}
-```
-
----
-
-### Use Case 7: First-Time vs Restored State
-
-**Problem:** Need to play intro animation only on first visit, not when restoring from save.
-
-**Solution:**
-```csharp
-public class LevelIntro : ManagedBehaviour
-{
-    public override bool AutoRegisterForSave => true;
-    
-    private bool _hasPlayedIntro;
-
-    internal override string OnSceneSaveRequested()
-    {
-        return JsonUtility.ToJson(new { hasPlayed = _hasPlayedIntro });
-    }
-
-    internal override void OnSceneRestoreRequested(string data)
-    {
-        var save = JsonUtility.FromJson<SaveData>(data);
-        _hasPlayedIntro = save.hasPlayed;
-    }
-
-    internal override void OnSceneRestoreCompleted()
-    {
-        // This fires whether we restored or not
-        if (!_hasPlayedIntro)
-        {
-            PlayIntroAnimation();
-            _hasPlayedIntro = true;
-        }
-    }
-}
-```
-
----
-
-
-## Common Patterns
-
-### Pattern: Manager Singleton
-```csharp
-public class MyManager : ManagedBehaviour
-{
-    private static MyManager _instance;
-    public static MyManager Instance => _instance;
-
-    internal override void OnManagedAwake()
-    {
-        _instance = this;
-    }
-}
-```
-
-### Pattern: Event Subscription
-```csharp
-internal override void OnManagedStart()
-{
-    EventBus.OnSomething += HandleEvent;
-}
-
-internal override void OnManagedDestroy()
-{
-    EventBus.OnSomething -= HandleEvent;
-}
-```
-
-### Pattern: Save/Restore
-```csharp
-public override bool AutoRegisterForSave => true;
-
-internal override string OnSceneSaveRequested()
-{
-    return JsonUtility.ToJson(myData);
-}
-
-internal override void OnSceneRestoreRequested(string data)
-{
-    myData = JsonUtility.FromJson<MyData>(data);
-}
-```
-
-### Pattern: Custom SaveId
-```csharp
-// For singletons or special cases
-public override string SaveId => "PlayerInventory";
-
-// For scene-specific instances
-public override string SaveId => $"{gameObject.scene.name}/MySpecialObject";
-```
-
-## Troubleshooting
-
-### "NullReferenceException when accessing Manager.Instance"
-**Problem:** Accessing singleton in `OnManagedAwake()`  
-**Solution:** Move to `OnManagedStart()` where managers are guaranteed ready
-
-### "My SaveId is colliding with another component"
-**Problem:** Two components have same GameObject name and type  
-**Solution:** Override `SaveId` property with unique value
-
-### "My component isn't receiving lifecycle callbacks"
-**Problem:** Not inheriting from `ManagedBehaviour`  
-**Solution:** Ensure class inherits `ManagedBehaviour` (not plain `MonoBehaviour`)
-
-### "Save data isn't persisting"
-**Problem:** `AutoRegisterForSave` is false  
-**Solution:** Set `public override bool AutoRegisterForSave => true;`
-
-### "OnSceneRestoreCompleted isn't firing"
-**Problem:** Missing implementation  
-**Solution:** Override the method even if just logging for now
-
----
-
-**Quick Links:**
-- [Technical Reference](01_technical_reference.md) - Complete API documentation
-- [Architecture Overview](02_architecture_overview.md) - System design and principles
-
-