diff --git a/README.md b/README.md
index b9fd184..a892a65 100644
--- a/README.md
+++ b/README.md
@@ -26,6 +26,7 @@ A Unity package of Roslyn source generators that take care of the boilerplate ar
 - [Singletons](#singletons)
   - [Attributes](#attributes)
   - [Guidance](#guidance)
+- [Lifecycle](#lifecycle)
 - [Requirements](#requirements)
 
 ---
@@ -142,18 +143,34 @@ public partial class SoundManager : ISoundManager
         return obj.AddComponent<SoundManager>();
     }
 
-    private void Awake()
+    // Returns false when this instance is a duplicate (gameObject has already
+    // been Destroy'd) so the lifecycle dispatcher can short-circuit.
+    private bool SingletonAwake()
     {
         var existing = ISoundManager.Instance as Object;
         if (existing != null && existing != this)
         {
             Object.Destroy(gameObject);
-            return;
+            return false;
         }
 
         transform.SetParent(null);
         DontDestroyOnLoad(gameObject);
         ISoundManager.Instance = this;
+        return true;
+    }
+}
+
+// Emitted by the Lifecycle generator (see below). Calls SingletonAwake first,
+// aborts on duplicate, then runs any user [Awake] methods, then OnAwake().
+public partial class SoundManager
+{
+    private void Awake()
+    {
+        if (!SingletonAwake())
+        {
+            return;
+        }
         OnAwake();
     }
 
@@ -180,7 +197,7 @@ The attribute accepts two optional arguments — a custom interface type and a `
 
 **`destroyOnLoad`** *(default: `false`)*
 
-By default the generated `Awake()` calls `DontDestroyOnLoad(gameObject)` and re-parents the host to the scene root, so the singleton outlives scene transitions. Set `destroyOnLoad: true` when you want the singleton scoped to its scene — useful for per-level managers that should reset on reload. With the flag on, the `DontDestroyOnLoad` and reparenting calls are omitted from the generated `Awake()`.
+By default the generated `SingletonAwake` helper calls `DontDestroyOnLoad(gameObject)` and re-parents the host to the scene root, so the singleton outlives scene transitions. Set `destroyOnLoad: true` when you want the singleton scoped to its scene — useful for per-level managers that should reset on reload. With the flag on, the `DontDestroyOnLoad` and reparenting calls are omitted from the helper.
 
 **Bring-your-own interface**
 
@@ -205,10 +222,11 @@ public partial class DataStoreManager : MonoBehaviour, IDataStoreManager
 
 | Member                    | What it does                                                                            |
 | ------------------------- | --------------------------------------------------------------------------------------- |
-| `I<ClassName>` interface  | Auto-generated when no interface is supplied. Lists the public-and-non-`[SingletonIgnore]` members of the class (or only `[SingletonInclude]`-tagged members in explicit mode). |
-| `static Create()`         | Factory that spawns a fresh GameObject named after the class and adds the component.    |
-| `private void Awake()`    | Publishes the instance, enforces the singleton invariant, optionally calls `DontDestroyOnLoad`. |
-| `partial void OnAwake()`  | Your hook — define it for post-awake setup; called after the instance is published.     |
+| `I<ClassName>` interface       | Auto-generated when no interface is supplied. Lists the public-and-non-`[SingletonIgnore]` members of the class (or only `[SingletonInclude]`-tagged members in explicit mode). |
+| `static Create()`              | Factory that spawns a fresh GameObject named after the class and adds the component.    |
+| `private bool SingletonAwake()`| Helper: publishes the instance, enforces the singleton invariant, optionally calls `DontDestroyOnLoad`. Returns `false` on a duplicate (after calling `Destroy(gameObject)`). |
+| `private void Awake()`         | Lifecycle dispatcher — emitted by the [Lifecycle](#lifecycle) generator. Calls `SingletonAwake()`, short-circuits on duplicate, then user `[Awake]` methods, then `OnAwake()`. |
+| `partial void OnAwake()`       | Back-compat hook — define it for post-awake setup; called after the instance is published. (For new code, prefer marking a method with `[Awake]`.) |
 
 </details>
 
@@ -287,9 +305,19 @@ This will generate the following code:
 ```csharp
 public partial class Egg
 {
-    private void Start()
+    private void DependencyStart()
     {
         _soundManager = ISoundManager.Instance;
+    }
+}
+
+// Emitted by the Lifecycle generator (see below). Calls DependencyStart first,
+// then any user [Start] methods, then OnStart().
+public partial class Egg
+{
+    private void Start()
+    {
+        DependencyStart();
         OnStart();
     }
 
@@ -297,7 +325,7 @@ public partial class Egg
 }
 ```
 
-Multiple `[Dependency]` fields on the same class are all assigned in the same generated `Start()` before `OnStart()` runs.
+Multiple `[Dependency]` fields on the same class are all assigned in the same generated `DependencyStart()` before any user `[Start]` methods or the back-compat `OnStart()` partial run.
 
 </details>
 
@@ -370,6 +398,98 @@ The `[DefaultExecutionOrder]` attribute makes `Bootstrap.Awake` run before any o
 
 ---
 
+## Lifecycle
+
+The Lifecycle generator turns Unity's lifecycle hooks (`Awake`, `Start`, `OnEnable`, `OnDisable`, `Update`, `FixedUpdate`, `LateUpdate`, `OnDestroy`) into method-level attributes. Mark as many methods as you like with `[Awake]`/`[Start]`/etc.; the generator emits a single dispatcher per hook that calls them all in order. This lets multiple features on the same MonoBehaviour cooperate on a lifecycle method without anyone owning `Awake()` outright — which is also how `[Singleton]` and `[Dependency]` integrate cleanly.
+
+<details>
+<summary><b>Lifecycle attributes</b> &nbsp;<sub>— hook into Unity's lifecycle without owning the method</sub></summary>
+
+&nbsp;
+
+One attribute per Unity message:
+
+| Attribute        | Generated dispatcher |
+| ---------------- | -------------------- |
+| `[Awake]`        | `private void Awake()` |
+| `[Start]`        | `private void Start()` |
+| `[OnEnable]`     | `private void OnEnable()` |
+| `[OnDisable]`    | `private void OnDisable()` |
+| `[Update]`       | `private void Update()` |
+| `[FixedUpdate]`  | `private void FixedUpdate()` |
+| `[LateUpdate]`   | `private void LateUpdate()` |
+| `[OnDestroy]`    | `private void OnDestroy()` |
+
+```csharp
+using EngineRoom.Runtime.Lifecycle;
+using UnityEngine;
+
+public partial class Player : MonoBehaviour
+{
+    [Awake]
+    private void WireInput() { /* … */ }
+
+    [Awake]
+    private void CacheComponents() { /* … */ }
+
+    [Update(order: -10)]
+    private void PollInput() { /* runs before any unordered [Update] */ }
+
+    [Update]
+    private void Step() { /* … */ }
+
+    [OnDestroy]
+    private void Unsubscribe() { /* … */ }
+}
+```
+
+The generator emits a single partial:
+
+```csharp
+public partial class Player
+{
+    private void Awake()
+    {
+        WireInput();
+        CacheComponents();
+        OnAwake();              // back-compat hook (always declared for Awake/Start)
+    }
+
+    partial void OnAwake();
+
+    private void Update()
+    {
+        PollInput();            // order = -10, runs first
+        Step();                 // unordered, source position
+    }
+
+    private void OnDestroy()
+    {
+        Unsubscribe();
+    }
+}
+```
+
+#### Ordering
+
+Each attribute takes an optional `int order` (defaults to `0`). Methods are sorted by ascending `Order`, then by their declaration position in source for stable ties. Methods without an explicit order intermix with `order: 0` and follow source order among themselves. When two methods on the same lifecycle share the same **explicit** order, the analyzer warns (`ERG0205`) and the tiebreak falls back to source position.
+
+#### Interaction with `[Singleton]` and `[Dependency]`
+
+`[Singleton]` always runs its `SingletonAwake()` helper **before** any user `[Awake]` methods on the same class, and short-circuits the rest of the dispatcher on a duplicate (the `gameObject` has been `Destroy`'d). `[Dependency]` always resolves fields via `DependencyStart()` **before** any user `[Start]` methods. These are special-cased — they don't participate in `Order` sorting.
+
+For backwards compatibility, the `Awake` and `Start` dispatchers still call (and declare) the `OnAwake()` and `OnStart()` partial hooks at the end, so existing code that implemented those keeps working. New code is encouraged to use `[Awake]`/`[Start]`-marked methods instead.
+
+#### Constraints
+
+- The host class must be `partial` and inherit from `MonoBehaviour` (`ERG0201`, `ERG0202`).
+- A lifecycle-attributed method must be an instance method, take no parameters, and return `void` (`ERG0204`).
+- The class must not define the lifecycle entry-point method directly (e.g. `void Awake()` when the class also has `[Awake]` methods or `[Singleton]`) — the generator emits it (`ERG0203`).
+
+</details>
+
+---
+
 ## Requirements
 
 Unity **2022.3** or newer. Tested on **Unity 2022.3.62** and **Unity 6000.4.0f1**.
diff --git a/src/generators-src/EngineRoom.Generators/Dependency/DependencyAnalyzer.cs b/src/generators-src/EngineRoom.Generators/Dependency/DependencyAnalyzer.cs
index 47f8317..46c70c6 100644
--- a/src/generators-src/EngineRoom.Generators/Dependency/DependencyAnalyzer.cs
+++ b/src/generators-src/EngineRoom.Generators/Dependency/DependencyAnalyzer.cs
@@ -18,7 +18,6 @@ public sealed class DependencyAnalyzer : DiagnosticAnalyzer
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
             DependencyDiagnostics.MustBeMonoBehaviour,
             DependencyDiagnostics.MustBePartial,
-            DependencyDiagnostics.MustNotDefineStart,
             DependencyDiagnostics.FieldMustBeNonPublicInstance,
             DependencyDiagnostics.FieldTypeMustBeSingletonInterface);
 
@@ -66,16 +65,9 @@ private static void AnalyzeNamedType(SymbolAnalysisContext ctx)
                 ctx.ReportDiagnostic(Diagnostic.Create(DependencyDiagnostics.MustBePartial, classLocation, className));
             }
 
-            var existingStart = classSymbol.GetMembers("Start")
-                .OfType<IMethodSymbol>()
-                .FirstOrDefault(static method => method.MethodKind == MethodKind.Ordinary
-                    && method.Parameters.Length == 0
-                    && !method.IsStatic);
-            if (existingStart is not null)
-            {
-                var startLocation = existingStart.Locations.FirstOrDefault() ?? classLocation;
-                ctx.ReportDiagnostic(Diagnostic.Create(DependencyDiagnostics.MustNotDefineStart, startLocation, className));
-            }
+            // User-defined Start() conflict is the Lifecycle analyzer's job now:
+            // [Dependency] no longer emits Start itself — it emits a
+            // DependencyStart helper that the lifecycle dispatcher calls.
         }
 
         private static void AnalyzeField(SymbolAnalysisContext ctx)
diff --git a/src/generators-src/EngineRoom.Generators/Dependency/DependencyDiagnostics.cs b/src/generators-src/EngineRoom.Generators/Dependency/DependencyDiagnostics.cs
index 64de39d..4c98aa2 100644
--- a/src/generators-src/EngineRoom.Generators/Dependency/DependencyDiagnostics.cs
+++ b/src/generators-src/EngineRoom.Generators/Dependency/DependencyDiagnostics.cs
@@ -22,13 +22,9 @@ internal static class DependencyDiagnostics
             defaultSeverity: DiagnosticSeverity.Error,
             isEnabledByDefault: true);
 
-        public static readonly DiagnosticDescriptor MustNotDefineStart = new DiagnosticDescriptor(
-            id: "ERG0103",
-            title: "[Dependency] host class must not define its own Start",
-            messageFormat: "Class '{0}' has a [Dependency] field and must not define a Start() method. Move that code into OnStart() instead.",
-            category: Category,
-            defaultSeverity: DiagnosticSeverity.Error,
-            isEnabledByDefault: true);
+        // ERG0103 ("must not define Start") retired with the lifecycle refactor —
+        // the equivalent check now lives in LifecycleAnalyzer (ERG0203). ID kept
+        // reserved so it can't be silently reused for an unrelated diagnostic.
 
         public static readonly DiagnosticDescriptor FieldMustBeNonPublicInstance = new DiagnosticDescriptor(
             id: "ERG0104",
diff --git a/src/generators-src/EngineRoom.Generators/Dependency/DependencyGenerator.cs b/src/generators-src/EngineRoom.Generators/Dependency/DependencyGenerator.cs
index 707642d..5983e18 100644
--- a/src/generators-src/EngineRoom.Generators/Dependency/DependencyGenerator.cs
+++ b/src/generators-src/EngineRoom.Generators/Dependency/DependencyGenerator.cs
@@ -61,16 +61,6 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 return null;
             }
 
-            var hasOwnStart = classSymbol.GetMembers("Start")
-                .OfType<IMethodSymbol>()
-                .Any(static method => method.MethodKind == MethodKind.Ordinary
-                    && method.Parameters.Length == 0
-                    && !method.IsStatic);
-            if (hasOwnStart)
-            {
-                return null;
-            }
-
             if (fieldSymbol.IsStatic)
             {
                 return null;
diff --git a/src/generators-src/EngineRoom.Generators/EngineRoom.Generators.csproj b/src/generators-src/EngineRoom.Generators/EngineRoom.Generators.csproj
index fc3f146..a8e01ab 100644
--- a/src/generators-src/EngineRoom.Generators/EngineRoom.Generators.csproj
+++ b/src/generators-src/EngineRoom.Generators/EngineRoom.Generators.csproj
@@ -41,6 +41,14 @@
     <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Singleton\Attributes\SingletonIncludeAttribute.cs" Link="Linked\Singleton\Attributes\SingletonIncludeAttribute.cs" />
     <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Singleton\Attributes\SingletonIgnoreAttribute.cs" Link="Linked\Singleton\Attributes\SingletonIgnoreAttribute.cs" />
     <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Singleton\Attributes\DependencyAttribute.cs" Link="Linked\Singleton\Attributes\DependencyAttribute.cs" />
+    <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Lifecycle\Attributes\AwakeAttribute.cs" Link="Linked\Lifecycle\Attributes\AwakeAttribute.cs" />
+    <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Lifecycle\Attributes\StartAttribute.cs" Link="Linked\Lifecycle\Attributes\StartAttribute.cs" />
+    <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Lifecycle\Attributes\OnEnableAttribute.cs" Link="Linked\Lifecycle\Attributes\OnEnableAttribute.cs" />
+    <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Lifecycle\Attributes\OnDisableAttribute.cs" Link="Linked\Lifecycle\Attributes\OnDisableAttribute.cs" />
+    <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Lifecycle\Attributes\UpdateAttribute.cs" Link="Linked\Lifecycle\Attributes\UpdateAttribute.cs" />
+    <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Lifecycle\Attributes\FixedUpdateAttribute.cs" Link="Linked\Lifecycle\Attributes\FixedUpdateAttribute.cs" />
+    <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Lifecycle\Attributes\LateUpdateAttribute.cs" Link="Linked\Lifecycle\Attributes\LateUpdateAttribute.cs" />
+    <Compile Include="..\..\generators-unity\Packages\games.engine-room.generators\Runtime\Lifecycle\Attributes\OnDestroyAttribute.cs" Link="Linked\Lifecycle\Attributes\OnDestroyAttribute.cs" />
   </ItemGroup>
 
   <!-- Release builds drop the generator dll into the Unity package so the
diff --git a/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleAnalyzer.cs b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleAnalyzer.cs
new file mode 100644
index 0000000..1aa53e1
--- /dev/null
+++ b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleAnalyzer.cs
@@ -0,0 +1,316 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using EngineRoom.Generators.Dependency;
+using EngineRoom.Generators.Helpers;
+using EngineRoom.Generators.Singleton;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace EngineRoom.Generators.Lifecycle
+{
+    // Owns the ERG02xx range. LifecycleGenerator silently skips invalid input,
+    // so every user-facing error/warning surfaces from here.
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public sealed class LifecycleAnalyzer : DiagnosticAnalyzer
+    {
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
+            LifecycleDiagnostics.MustBeMonoBehaviour,
+            LifecycleDiagnostics.MustBePartial,
+            LifecycleDiagnostics.MustNotDefineLifecycleMethod,
+            LifecycleDiagnostics.MethodMustBeInstanceVoidParameterless,
+            LifecycleDiagnostics.DuplicateExplicitOrder);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.EnableConcurrentExecution();
+            context.RegisterSymbolAction(AnalyzeNamedType, SymbolKind.NamedType);
+        }
+
+        private static void AnalyzeNamedType(SymbolAnalysisContext ctx)
+        {
+            if (ctx.Symbol is not INamedTypeSymbol classSymbol || classSymbol.TypeKind != TypeKind.Class)
+            {
+                return;
+            }
+
+            // Discover what dispatchers the generator will emit for this class:
+            // one per lifecycle kind that has at least one attributed method, plus
+            // Awake if the class is [Singleton], plus Start if any field has
+            // [Dependency]. Methods with bad signatures are still reported so the
+            // user sees the real reason their attribute is being ignored.
+            var attributedMethods = new List<AttributedMethod>();
+            var dispatcherKinds = new bool[LifecycleKinds.Count];
+            var hasDependencyField = false;
+
+            foreach (var member in classSymbol.GetMembers())
+            {
+                if (member is IFieldSymbol field
+                    && SymbolInspector.HasAttribute(field, DependencyConstants.AttributeFullName))
+                {
+                    hasDependencyField = true;
+                    continue;
+                }
+
+                if (member is not IMethodSymbol method || method.MethodKind != MethodKind.Ordinary)
+                {
+                    continue;
+                }
+
+                foreach (var attribute in method.GetAttributes())
+                {
+                    var attributeName = attribute.AttributeClass?.ToDisplayString();
+                    if (attributeName is null)
+                    {
+                        continue;
+                    }
+
+                    for (int k = 0; k < LifecycleKinds.Count; k++)
+                    {
+                        var kind = (LifecycleKind)k;
+                        if (attributeName != LifecycleKinds.AttributeFullName(kind))
+                        {
+                            continue;
+                        }
+
+                        attributedMethods.Add(new AttributedMethod(method, kind, attribute));
+                        dispatcherKinds[k] = true;
+                    }
+                }
+            }
+
+            var hasSingletonAttribute = SymbolInspector.HasAttribute(classSymbol, SingletonConstants.AttributeFullName);
+            if (hasSingletonAttribute)
+            {
+                dispatcherKinds[(int)LifecycleKind.Awake] = true;
+            }
+
+            if (hasDependencyField)
+            {
+                dispatcherKinds[(int)LifecycleKind.Start] = true;
+            }
+
+            var willGenerateAnyDispatcher = false;
+            for (int k = 0; k < LifecycleKinds.Count; k++)
+            {
+                if (dispatcherKinds[k])
+                {
+                    willGenerateAnyDispatcher = true;
+                    break;
+                }
+            }
+
+            // Nothing to dispatch and no attributes to validate — leave the class
+            // alone. [Singleton]/[Dependency] structural checks live in their own
+            // analyzers; ERG02xx only fires when this generator actually emits.
+            if (!willGenerateAnyDispatcher)
+            {
+                return;
+            }
+
+            var classLocation = GetClassIdentifierLocation(classSymbol) ?? Location.None;
+            var className = classSymbol.Name;
+
+            if (attributedMethods.Count > 0
+                && !SymbolInspector.InheritsFrom(classSymbol, LifecycleConstants.MonoBehaviourFullyQualifiedName))
+            {
+                // [Singleton]/[Dependency] already own the MonoBehaviour check on
+                // their own attributes; only report here for lifecycle attributes
+                // (where this analyzer is the only signal).
+                foreach (var attributed in attributedMethods)
+                {
+                    ctx.ReportDiagnostic(Diagnostic.Create(
+                        LifecycleDiagnostics.MustBeMonoBehaviour,
+                        attributed.Method.Locations.FirstOrDefault() ?? classLocation,
+                        attributed.Method.Name));
+                }
+            }
+
+            if (attributedMethods.Count > 0 && !SymbolInspector.IsPartial(classSymbol))
+            {
+                ctx.ReportDiagnostic(Diagnostic.Create(LifecycleDiagnostics.MustBePartial, classLocation, className));
+            }
+
+            ValidateAttributedMethodSignatures(ctx, attributedMethods);
+            ValidateUserDefinedLifecycleConflicts(ctx, classSymbol, dispatcherKinds, className);
+            ValidateExplicitOrderUniqueness(ctx, attributedMethods);
+        }
+
+        private static void ValidateAttributedMethodSignatures(
+            SymbolAnalysisContext ctx,
+            List<AttributedMethod> attributedMethods)
+        {
+            foreach (var attributed in attributedMethods)
+            {
+                var method = attributed.Method;
+                if (method.Parameters.Length == 0 && method.ReturnsVoid && !method.IsStatic)
+                {
+                    continue;
+                }
+
+                ctx.ReportDiagnostic(Diagnostic.Create(
+                    LifecycleDiagnostics.MethodMustBeInstanceVoidParameterless,
+                    method.Locations.FirstOrDefault() ?? Location.None,
+                    method.Name,
+                    LifecycleKinds.MethodName(attributed.Kind)));
+            }
+        }
+
+        private static void ValidateUserDefinedLifecycleConflicts(
+            SymbolAnalysisContext ctx,
+            INamedTypeSymbol classSymbol,
+            bool[] dispatcherKinds,
+            string className)
+        {
+            for (int k = 0; k < LifecycleKinds.Count; k++)
+            {
+                if (!dispatcherKinds[k])
+                {
+                    continue;
+                }
+
+                var kind = (LifecycleKind)k;
+                var lifecycleMethodName = LifecycleKinds.MethodName(kind);
+
+                // Walk members named exactly the lifecycle entry point and report
+                // any user-defined ones (signature: parameterless instance) — the
+                // generator's dispatcher will collide with them.
+                foreach (var candidate in classSymbol.GetMembers(lifecycleMethodName))
+                {
+                    if (candidate is not IMethodSymbol method
+                        || method.MethodKind != MethodKind.Ordinary
+                        || method.IsStatic
+                        || method.Parameters.Length != 0)
+                    {
+                        continue;
+                    }
+
+                    var location = method.Locations.FirstOrDefault() ?? Location.None;
+                    ctx.ReportDiagnostic(Diagnostic.Create(
+                        LifecycleDiagnostics.MustNotDefineLifecycleMethod,
+                        location,
+                        className,
+                        lifecycleMethodName));
+                }
+            }
+        }
+
+        private static void ValidateExplicitOrderUniqueness(
+            SymbolAnalysisContext ctx,
+            List<AttributedMethod> attributedMethods)
+        {
+            // Same explicit Order within the same kind: degrades to source-order,
+            // which is rarely what the user intends; warn so they can spot it.
+            var groupedByKind = new Dictionary<LifecycleKind, List<AttributedMethod>>();
+            foreach (var attributed in attributedMethods)
+            {
+                if (!groupedByKind.TryGetValue(attributed.Kind, out var list))
+                {
+                    list = new List<AttributedMethod>();
+                    groupedByKind[attributed.Kind] = list;
+                }
+                list.Add(attributed);
+            }
+
+            foreach (var pair in groupedByKind)
+            {
+                var kind = pair.Key;
+                var groupByOrder = new Dictionary<int, List<AttributedMethod>>();
+                foreach (var attributed in pair.Value)
+                {
+                    var (order, hasExplicit) = ReadOrder(attributed.Attribute);
+                    if (!hasExplicit)
+                    {
+                        continue;
+                    }
+
+                    if (!groupByOrder.TryGetValue(order, out var list))
+                    {
+                        list = new List<AttributedMethod>();
+                        groupByOrder[order] = list;
+                    }
+                    list.Add(attributed);
+                }
+
+                foreach (var orderPair in groupByOrder)
+                {
+                    if (orderPair.Value.Count < 2)
+                    {
+                        continue;
+                    }
+
+                    var attributeName = LifecycleKinds.MethodName(kind);
+                    var orderText = orderPair.Key.ToString(System.Globalization.CultureInfo.InvariantCulture);
+                    for (int i = 0; i < orderPair.Value.Count; i++)
+                    {
+                        var current = orderPair.Value[i];
+                        var other = orderPair.Value[(i + 1) % orderPair.Value.Count];
+                        ctx.ReportDiagnostic(Diagnostic.Create(
+                            LifecycleDiagnostics.DuplicateExplicitOrder,
+                            current.Method.Locations.FirstOrDefault() ?? Location.None,
+                            current.Method.Name,
+                            attributeName,
+                            orderText,
+                            other.Method.Name));
+                    }
+                }
+            }
+        }
+
+        private static (int Order, bool HasExplicitOrder) ReadOrder(AttributeData attribute)
+        {
+            int order = 0;
+            bool hasExplicitOrder = false;
+
+            if (attribute.AttributeConstructor is { Parameters.Length: 1 }
+                && attribute.ConstructorArguments.Length == 1
+                && attribute.ConstructorArguments[0].Value is int parsed)
+            {
+                order = parsed;
+                hasExplicitOrder = true;
+            }
+
+            foreach (var named in attribute.NamedArguments)
+            {
+                if (named.Key == "Order" && named.Value.Value is int namedOrder)
+                {
+                    order = namedOrder;
+                    hasExplicitOrder = true;
+                }
+            }
+
+            return (order, hasExplicitOrder);
+        }
+
+        private static Location? GetClassIdentifierLocation(INamedTypeSymbol classSymbol)
+        {
+            foreach (var reference in classSymbol.DeclaringSyntaxReferences)
+            {
+                if (reference.GetSyntax() is ClassDeclarationSyntax declaration)
+                {
+                    return declaration.Identifier.GetLocation();
+                }
+            }
+
+            return classSymbol.Locations.FirstOrDefault();
+        }
+
+        private readonly struct AttributedMethod
+        {
+            public AttributedMethod(IMethodSymbol method, LifecycleKind kind, AttributeData attribute)
+            {
+                Method = method;
+                Kind = kind;
+                Attribute = attribute;
+            }
+
+            public IMethodSymbol Method { get; }
+
+            public LifecycleKind Kind { get; }
+
+            public AttributeData Attribute { get; }
+        }
+    }
+}
diff --git a/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleConstants.cs b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleConstants.cs
new file mode 100644
index 0000000..06c5cb7
--- /dev/null
+++ b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleConstants.cs
@@ -0,0 +1,22 @@
+namespace EngineRoom.Generators.Lifecycle
+{
+    internal static class LifecycleConstants
+    {
+        public static readonly string AwakeAttributeFullName = typeof(global::EngineRoom.Runtime.Lifecycle.AwakeAttribute).FullName!;
+        public static readonly string StartAttributeFullName = typeof(global::EngineRoom.Runtime.Lifecycle.StartAttribute).FullName!;
+        public static readonly string OnEnableAttributeFullName = typeof(global::EngineRoom.Runtime.Lifecycle.OnEnableAttribute).FullName!;
+        public static readonly string OnDisableAttributeFullName = typeof(global::EngineRoom.Runtime.Lifecycle.OnDisableAttribute).FullName!;
+        public static readonly string UpdateAttributeFullName = typeof(global::EngineRoom.Runtime.Lifecycle.UpdateAttribute).FullName!;
+        public static readonly string FixedUpdateAttributeFullName = typeof(global::EngineRoom.Runtime.Lifecycle.FixedUpdateAttribute).FullName!;
+        public static readonly string LateUpdateAttributeFullName = typeof(global::EngineRoom.Runtime.Lifecycle.LateUpdateAttribute).FullName!;
+        public static readonly string OnDestroyAttributeFullName = typeof(global::EngineRoom.Runtime.Lifecycle.OnDestroyAttribute).FullName!;
+
+        public const string MonoBehaviourFullyQualifiedName = "global::UnityEngine.MonoBehaviour";
+
+        // Names of the per-feature helpers contributed by sibling generators.
+        // Singleton emits a bool helper (false = duplicate, Destroy called, bail).
+        // Dependency emits a void helper (field assignments).
+        public const string SingletonAwakeHelperName = "SingletonAwake";
+        public const string DependencyStartHelperName = "DependencyStart";
+    }
+}
diff --git a/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleDiagnostics.cs b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleDiagnostics.cs
new file mode 100644
index 0000000..5893725
--- /dev/null
+++ b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleDiagnostics.cs
@@ -0,0 +1,49 @@
+using Microsoft.CodeAnalysis;
+
+namespace EngineRoom.Generators.Lifecycle
+{
+    internal static class LifecycleDiagnostics
+    {
+        private const string Category = "EngineRoom.Runtime.Lifecycle";
+
+        public static readonly DiagnosticDescriptor MustBeMonoBehaviour = new DiagnosticDescriptor(
+            id: "ERG0201",
+            title: "Lifecycle attributes require a MonoBehaviour",
+            messageFormat: "Method '{0}' is decorated with a lifecycle attribute but its containing class does not inherit from UnityEngine.MonoBehaviour",
+            category: Category,
+            defaultSeverity: DiagnosticSeverity.Error,
+            isEnabledByDefault: true);
+
+        public static readonly DiagnosticDescriptor MustBePartial = new DiagnosticDescriptor(
+            id: "ERG0202",
+            title: "Lifecycle attributes require a partial class",
+            messageFormat: "Class '{0}' uses lifecycle attributes and must be declared partial",
+            category: Category,
+            defaultSeverity: DiagnosticSeverity.Error,
+            isEnabledByDefault: true);
+
+        public static readonly DiagnosticDescriptor MustNotDefineLifecycleMethod = new DiagnosticDescriptor(
+            id: "ERG0203",
+            title: "Generated lifecycle method conflicts with user-defined one",
+            messageFormat: "Class '{0}' must not define its own '{1}()' method — a generated lifecycle dispatcher will conflict. Move that code into a private method marked with [{1}] instead.",
+            category: Category,
+            defaultSeverity: DiagnosticSeverity.Error,
+            isEnabledByDefault: true);
+
+        public static readonly DiagnosticDescriptor MethodMustBeInstanceVoidParameterless = new DiagnosticDescriptor(
+            id: "ERG0204",
+            title: "Lifecycle methods must be instance, parameterless, and return void",
+            messageFormat: "Method '{0}' is decorated with [{1}] and must be an instance method, take no parameters, and return void",
+            category: Category,
+            defaultSeverity: DiagnosticSeverity.Error,
+            isEnabledByDefault: true);
+
+        public static readonly DiagnosticDescriptor DuplicateExplicitOrder = new DiagnosticDescriptor(
+            id: "ERG0205",
+            title: "Two lifecycle methods share the same explicit order",
+            messageFormat: "Method '{0}' shares explicit [{1}({2})] order with method '{3}'. Their relative invocation order falls back to source declaration order.",
+            category: Category,
+            defaultSeverity: DiagnosticSeverity.Warning,
+            isEnabledByDefault: true);
+    }
+}
diff --git a/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleEntry.cs b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleEntry.cs
new file mode 100644
index 0000000..ef20477
--- /dev/null
+++ b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleEntry.cs
@@ -0,0 +1,53 @@
+using System;
+
+namespace EngineRoom.Generators.Lifecycle
+{
+    // Strings + primitives only so the incremental cache key doesn't depend on
+    // Roslyn symbol or Location identity (which churns between compilations).
+    internal readonly struct LifecycleEntry : IEquatable<LifecycleEntry>
+    {
+        public LifecycleEntry(string methodName, int order, bool hasExplicitOrder, int declarationPosition)
+        {
+            MethodName = methodName;
+            Order = order;
+            HasExplicitOrder = hasExplicitOrder;
+            DeclarationPosition = declarationPosition;
+        }
+
+        public string MethodName { get; }
+
+        public int Order { get; }
+
+        public bool HasExplicitOrder { get; }
+
+        // Source-text offset of the method declaration; used as the stable
+        // tiebreaker when two entries share the same Order.
+        public int DeclarationPosition { get; }
+
+        public bool Equals(LifecycleEntry other)
+        {
+            return MethodName == other.MethodName
+                && Order == other.Order
+                && HasExplicitOrder == other.HasExplicitOrder
+                && DeclarationPosition == other.DeclarationPosition;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            return obj is LifecycleEntry other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+                hash = hash * 31 + (MethodName?.GetHashCode() ?? 0);
+                hash = hash * 31 + Order;
+                hash = hash * 31 + (HasExplicitOrder ? 1 : 0);
+                hash = hash * 31 + DeclarationPosition;
+                return hash;
+            }
+        }
+    }
+}
diff --git a/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleGenerator.cs b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleGenerator.cs
new file mode 100644
index 0000000..dd3de9d
--- /dev/null
+++ b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleGenerator.cs
@@ -0,0 +1,347 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using EngineRoom.Generators.Dependency;
+using EngineRoom.Generators.Helpers;
+using EngineRoom.Generators.Singleton;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+namespace EngineRoom.Generators.Lifecycle
+{
+    // Owns dispatching for Unity's lifecycle methods (Awake, Start, OnEnable,
+    // OnDisable, Update, FixedUpdate, LateUpdate, OnDestroy). Methods marked
+    // with the matching [Awake]/[Start]/... attribute are invoked in source
+    // order, or by ascending Order when explicitly specified.
+    //
+    // Special cases handled inline (not via the attribute path, because sibling
+    // generators don't see this one's syntax tree):
+    //   - [Singleton] classes: Awake() calls SingletonAwake() first and aborts
+    //     on a 'false' return (duplicate instance — gameObject was Destroyed).
+    //   - Classes with any [Dependency] field: Start() calls DependencyStart()
+    //     before any user [Start] methods.
+    //
+    // Validation lives in LifecycleAnalyzer; this generator silently skips any
+    // input the analyzer would flag so its output never piles on top of a
+    // compile error.
+    [Generator(LanguageNames.CSharp)]
+    public sealed class LifecycleGenerator : IIncrementalGenerator
+    {
+        // Attribute simple names (with and without the trailing 'Attribute' suffix)
+        // used to cheaply pre-filter class candidates at the syntax level — the
+        // expensive semantic checks then run only on the survivors.
+        private static readonly HashSet<string> RelevantAttributeNames = new HashSet<string>(StringComparer.Ordinal)
+        {
+            "Awake", "AwakeAttribute",
+            "Start", "StartAttribute",
+            "OnEnable", "OnEnableAttribute",
+            "OnDisable", "OnDisableAttribute",
+            "Update", "UpdateAttribute",
+            "FixedUpdate", "FixedUpdateAttribute",
+            "LateUpdate", "LateUpdateAttribute",
+            "OnDestroy", "OnDestroyAttribute",
+            "Singleton", "SingletonAttribute",
+            "Dependency", "DependencyAttribute",
+        };
+
+        public void Initialize(IncrementalGeneratorInitializationContext context)
+        {
+            var infos = context.SyntaxProvider
+                .CreateSyntaxProvider(
+                    predicate: static (node, _) => IsCandidateClass(node),
+                    transform: static (ctx, _) => ExtractInfo(ctx))
+                .Where(static info => info is not null);
+
+            context.RegisterSourceOutput(infos, static (ctx, info) => Emit(ctx, info!));
+        }
+
+        private static bool IsCandidateClass(SyntaxNode node)
+        {
+            if (node is not ClassDeclarationSyntax classDecl)
+            {
+                return false;
+            }
+
+            if (HasRelevantAttribute(classDecl.AttributeLists))
+            {
+                return true;
+            }
+
+            foreach (var member in classDecl.Members)
+            {
+                if (HasRelevantAttribute(member.AttributeLists))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static bool HasRelevantAttribute(SyntaxList<AttributeListSyntax> lists)
+        {
+            foreach (var list in lists)
+            {
+                foreach (var attribute in list.Attributes)
+                {
+                    var simpleName = GetSimpleName(attribute.Name);
+                    if (simpleName is not null && RelevantAttributeNames.Contains(simpleName))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private static string? GetSimpleName(NameSyntax name)
+        {
+            return name switch
+            {
+                IdentifierNameSyntax identifier => identifier.Identifier.Text,
+                QualifiedNameSyntax qualified => qualified.Right.Identifier.Text,
+                AliasQualifiedNameSyntax aliased => aliased.Name.Identifier.Text,
+                _ => null,
+            };
+        }
+
+        private static LifecycleInfo? ExtractInfo(GeneratorSyntaxContext ctx)
+        {
+            var classDecl = (ClassDeclarationSyntax)ctx.Node;
+            if (!classDecl.Modifiers.Any(SyntaxKind.PartialKeyword))
+            {
+                return null;
+            }
+
+            if (ctx.SemanticModel.GetDeclaredSymbol(classDecl) is not INamedTypeSymbol classSymbol)
+            {
+                return null;
+            }
+
+            if (!SymbolInspector.InheritsFrom(classSymbol, LifecycleConstants.MonoBehaviourFullyQualifiedName))
+            {
+                return null;
+            }
+
+            // A partial class hits this transform once per declaration; pick the
+            // first declaration (by source position) so the dispatcher is emitted
+            // exactly once even when the user splits the class across files.
+            if (!IsPrimaryDeclaration(classSymbol, classDecl))
+            {
+                return null;
+            }
+
+            var hasSingleton = SymbolInspector.HasAttribute(classSymbol, SingletonConstants.AttributeFullName);
+            var hasDependencyField = false;
+
+            var bucketBuilders = new ImmutableArray<LifecycleEntry>.Builder[LifecycleKinds.Count];
+            for (int i = 0; i < LifecycleKinds.Count; i++)
+            {
+                bucketBuilders[i] = ImmutableArray.CreateBuilder<LifecycleEntry>();
+            }
+
+            foreach (var member in classSymbol.GetMembers())
+            {
+                if (!hasDependencyField
+                    && member is IFieldSymbol field
+                    && SymbolInspector.HasAttribute(field, DependencyConstants.AttributeFullName))
+                {
+                    hasDependencyField = true;
+                }
+
+                if (member is not IMethodSymbol method
+                    || method.MethodKind != MethodKind.Ordinary
+                    || method.IsStatic
+                    || method.Parameters.Length != 0
+                    || !method.ReturnsVoid)
+                {
+                    continue;
+                }
+
+                foreach (var attribute in method.GetAttributes())
+                {
+                    var attributeName = attribute.AttributeClass?.ToDisplayString();
+                    if (attributeName is null)
+                    {
+                        continue;
+                    }
+
+                    for (int k = 0; k < LifecycleKinds.Count; k++)
+                    {
+                        var kind = (LifecycleKind)k;
+                        if (attributeName != LifecycleKinds.AttributeFullName(kind))
+                        {
+                            continue;
+                        }
+
+                        var (order, hasExplicitOrder) = ReadOrder(attribute);
+                        var declarationPosition = method.DeclaringSyntaxReferences.Length > 0
+                            ? method.DeclaringSyntaxReferences[0].Span.Start
+                            : 0;
+
+                        bucketBuilders[k].Add(new LifecycleEntry(
+                            methodName: method.Name,
+                            order: order,
+                            hasExplicitOrder: hasExplicitOrder,
+                            declarationPosition: declarationPosition));
+                    }
+                }
+            }
+
+            var buckets = ImmutableArray.CreateBuilder<ImmutableArray<LifecycleEntry>>(LifecycleKinds.Count);
+            for (int i = 0; i < LifecycleKinds.Count; i++)
+            {
+                buckets.Add(bucketBuilders[i].ToImmutable().Sort(static (left, right) =>
+                {
+                    int compare = left.Order.CompareTo(right.Order);
+                    return compare != 0 ? compare : left.DeclarationPosition.CompareTo(right.DeclarationPosition);
+                }));
+            }
+
+            var containingNamespace = classSymbol.ContainingNamespace.IsGlobalNamespace
+                ? null
+                : classSymbol.ContainingNamespace.ToDisplayString();
+            var hintPrefix = containingNamespace is null
+                ? classSymbol.Name
+                : containingNamespace + "." + classSymbol.Name;
+
+            var info = new LifecycleInfo(
+                className: classSymbol.Name,
+                @namespace: containingNamespace,
+                hintPrefix: hintPrefix,
+                hasSingleton: hasSingleton,
+                hasDependencyField: hasDependencyField,
+                entriesByKind: buckets.ToImmutable());
+
+            return info.HasAnyEntries ? info : null;
+        }
+
+        private static (int Order, bool HasExplicitOrder) ReadOrder(AttributeData attribute)
+        {
+            int order = 0;
+            bool hasExplicitOrder = false;
+
+            // Ctor `(int order)` overload — the parameterless ctor leaves the
+            // ConstructorArguments collection empty so we can distinguish
+            // "unspecified" from "explicit 0".
+            if (attribute.AttributeConstructor is { Parameters.Length: 1 }
+                && attribute.ConstructorArguments.Length == 1
+                && attribute.ConstructorArguments[0].Value is int parsed)
+            {
+                order = parsed;
+                hasExplicitOrder = true;
+            }
+
+            foreach (var named in attribute.NamedArguments)
+            {
+                if (named.Key == "Order" && named.Value.Value is int namedOrder)
+                {
+                    order = namedOrder;
+                    hasExplicitOrder = true;
+                }
+            }
+
+            return (order, hasExplicitOrder);
+        }
+
+        private static bool IsPrimaryDeclaration(INamedTypeSymbol classSymbol, ClassDeclarationSyntax candidate)
+        {
+            if (classSymbol.DeclaringSyntaxReferences.Length == 0)
+            {
+                return false;
+            }
+
+            // SyntaxNode identity isn't stable across compilations; compare by
+            // tree+span instead.
+            var first = classSymbol.DeclaringSyntaxReferences[0];
+            return first.SyntaxTree == candidate.SyntaxTree && first.Span == candidate.Span;
+        }
+
+        private static void Emit(SourceProductionContext ctx, LifecycleInfo info)
+        {
+            var methodsBlock = new StringBuilder();
+            bool first = true;
+
+            for (int k = 0; k < LifecycleKinds.Count; k++)
+            {
+                var kind = (LifecycleKind)k;
+                var entries = info.EntriesByKind[k];
+                var includeSingleton = kind == LifecycleKind.Awake && info.HasSingleton;
+                var includeDependency = kind == LifecycleKind.Start && info.HasDependencyField;
+                var backCompat = LifecycleKinds.BackCompatPartialName(kind);
+
+                if (entries.Length == 0 && !includeSingleton && !includeDependency)
+                {
+                    continue;
+                }
+
+                if (!first)
+                {
+                    methodsBlock.Append('\n');
+                }
+                first = false;
+
+                AppendDispatcher(methodsBlock, LifecycleKinds.MethodName(kind), entries, includeSingleton, includeDependency, backCompat);
+            }
+
+            var body = TemplateLoader.LoadAndSubstitute("Lifecycle/LifecyclePartial", new Dictionary<string, string>
+            {
+                ["ClassName"] = info.ClassName,
+                ["Methods"] = methodsBlock.ToString().TrimEnd('\n'),
+            });
+
+            var text = SourceFileBuilder.Build(body, info.Namespace);
+            ctx.AddSource(info.HintPrefix + ".Lifecycle.Partial.g.cs", SourceText.From(text, Encoding.UTF8));
+        }
+
+        private static void AppendDispatcher(
+            StringBuilder builder,
+            string methodName,
+            ImmutableArray<LifecycleEntry> entries,
+            bool includeSingleton,
+            bool includeDependency,
+            string? backCompatPartialName)
+        {
+            builder.Append("private void ").Append(methodName).Append("()\n");
+            builder.Append("{\n");
+
+            if (includeSingleton)
+            {
+                // Short-circuit on duplicate: the SingletonAwake helper has
+                // already called Destroy(gameObject); calling any further user
+                // [Awake] methods on a doomed object would be a bug.
+                builder.Append("    if (!").Append(LifecycleConstants.SingletonAwakeHelperName).Append("())\n");
+                builder.Append("    {\n");
+                builder.Append("        return;\n");
+                builder.Append("    }\n");
+            }
+            else if (includeDependency)
+            {
+                builder.Append("    ").Append(LifecycleConstants.DependencyStartHelperName).Append("();\n");
+            }
+
+            foreach (var entry in entries)
+            {
+                builder.Append("    ").Append(entry.MethodName).Append("();\n");
+            }
+
+            if (backCompatPartialName is not null)
+            {
+                builder.Append("    ").Append(backCompatPartialName).Append("();\n");
+            }
+
+            builder.Append("}\n");
+
+            if (backCompatPartialName is not null)
+            {
+                builder.Append('\n');
+                builder.Append("partial void ").Append(backCompatPartialName).Append("();\n");
+            }
+        }
+    }
+}
diff --git a/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleInfo.cs b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleInfo.cs
new file mode 100644
index 0000000..69c8f81
--- /dev/null
+++ b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleInfo.cs
@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Immutable;
+
+namespace EngineRoom.Generators.Lifecycle
+{
+    internal sealed class LifecycleInfo : IEquatable<LifecycleInfo>
+    {
+        public LifecycleInfo(
+            string className,
+            string? @namespace,
+            string hintPrefix,
+            bool hasSingleton,
+            bool hasDependencyField,
+            ImmutableArray<ImmutableArray<LifecycleEntry>> entriesByKind)
+        {
+            ClassName = className;
+            Namespace = @namespace;
+            HintPrefix = hintPrefix;
+            HasSingleton = hasSingleton;
+            HasDependencyField = hasDependencyField;
+            EntriesByKind = entriesByKind;
+        }
+
+        public string ClassName { get; }
+
+        public string? Namespace { get; }
+
+        public string HintPrefix { get; }
+
+        public bool HasSingleton { get; }
+
+        public bool HasDependencyField { get; }
+
+        // Indexed by (int)LifecycleKind; always length LifecycleKinds.Count.
+        public ImmutableArray<ImmutableArray<LifecycleEntry>> EntriesByKind { get; }
+
+        public bool HasAnyEntries
+        {
+            get
+            {
+                if (HasSingleton || HasDependencyField)
+                {
+                    return true;
+                }
+
+                foreach (var bucket in EntriesByKind)
+                {
+                    if (bucket.Length > 0)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }
+
+        public bool Equals(LifecycleInfo? other)
+        {
+            if (other is null)
+            {
+                return false;
+            }
+
+            if (ClassName != other.ClassName
+                || Namespace != other.Namespace
+                || HintPrefix != other.HintPrefix
+                || HasSingleton != other.HasSingleton
+                || HasDependencyField != other.HasDependencyField
+                || EntriesByKind.Length != other.EntriesByKind.Length)
+            {
+                return false;
+            }
+
+            for (int kind = 0; kind < EntriesByKind.Length; kind++)
+            {
+                var left = EntriesByKind[kind];
+                var right = other.EntriesByKind[kind];
+                if (left.Length != right.Length)
+                {
+                    return false;
+                }
+
+                for (int index = 0; index < left.Length; index++)
+                {
+                    if (!left[index].Equals(right[index]))
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            return Equals(obj as LifecycleInfo);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+                hash = hash * 31 + (ClassName?.GetHashCode() ?? 0);
+                hash = hash * 31 + (Namespace?.GetHashCode() ?? 0);
+                hash = hash * 31 + (HintPrefix?.GetHashCode() ?? 0);
+                hash = hash * 31 + (HasSingleton ? 1 : 0);
+                hash = hash * 31 + (HasDependencyField ? 1 : 0);
+                foreach (var bucket in EntriesByKind)
+                {
+                    foreach (var entry in bucket)
+                    {
+                        hash = hash * 31 + entry.GetHashCode();
+                    }
+                }
+                return hash;
+            }
+        }
+    }
+}
diff --git a/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleKind.cs b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleKind.cs
new file mode 100644
index 0000000..5cde974
--- /dev/null
+++ b/src/generators-src/EngineRoom.Generators/Lifecycle/LifecycleKind.cs
@@ -0,0 +1,64 @@
+namespace EngineRoom.Generators.Lifecycle
+{
+    internal enum LifecycleKind
+    {
+        Awake = 0,
+        Start = 1,
+        OnEnable = 2,
+        OnDisable = 3,
+        Update = 4,
+        FixedUpdate = 5,
+        LateUpdate = 6,
+        OnDestroy = 7,
+    }
+
+    internal static class LifecycleKinds
+    {
+        public const int Count = 8;
+
+        public static string MethodName(LifecycleKind kind)
+        {
+            return kind switch
+            {
+                LifecycleKind.Awake => "Awake",
+                LifecycleKind.Start => "Start",
+                LifecycleKind.OnEnable => "OnEnable",
+                LifecycleKind.OnDisable => "OnDisable",
+                LifecycleKind.Update => "Update",
+                LifecycleKind.FixedUpdate => "FixedUpdate",
+                LifecycleKind.LateUpdate => "LateUpdate",
+                LifecycleKind.OnDestroy => "OnDestroy",
+                _ => string.Empty,
+            };
+        }
+
+        public static string AttributeFullName(LifecycleKind kind)
+        {
+            return kind switch
+            {
+                LifecycleKind.Awake => LifecycleConstants.AwakeAttributeFullName,
+                LifecycleKind.Start => LifecycleConstants.StartAttributeFullName,
+                LifecycleKind.OnEnable => LifecycleConstants.OnEnableAttributeFullName,
+                LifecycleKind.OnDisable => LifecycleConstants.OnDisableAttributeFullName,
+                LifecycleKind.Update => LifecycleConstants.UpdateAttributeFullName,
+                LifecycleKind.FixedUpdate => LifecycleConstants.FixedUpdateAttributeFullName,
+                LifecycleKind.LateUpdate => LifecycleConstants.LateUpdateAttributeFullName,
+                LifecycleKind.OnDestroy => LifecycleConstants.OnDestroyAttributeFullName,
+                _ => string.Empty,
+            };
+        }
+
+        // Awake and Start retain a back-compat partial hook (OnAwake / OnStart) so
+        // existing code that implements those partials keeps working after the
+        // Singleton / Dependency generators stop emitting them directly.
+        public static string? BackCompatPartialName(LifecycleKind kind)
+        {
+            return kind switch
+            {
+                LifecycleKind.Awake => "OnAwake",
+                LifecycleKind.Start => "OnStart",
+                _ => null,
+            };
+        }
+    }
+}
diff --git a/src/generators-src/EngineRoom.Generators/Singleton/SingletonAnalyzer.cs b/src/generators-src/EngineRoom.Generators/Singleton/SingletonAnalyzer.cs
index 97dd99f..aed9223 100644
--- a/src/generators-src/EngineRoom.Generators/Singleton/SingletonAnalyzer.cs
+++ b/src/generators-src/EngineRoom.Generators/Singleton/SingletonAnalyzer.cs
@@ -16,7 +16,6 @@ public sealed class SingletonAnalyzer : DiagnosticAnalyzer
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
             SingletonDiagnostics.MustBeMonoBehaviour,
             SingletonDiagnostics.MustBePartial,
-            SingletonDiagnostics.MustNotDefineAwake,
             SingletonDiagnostics.MemberMustBePublic,
             SingletonDiagnostics.MemberMustBeInstance,
             SingletonDiagnostics.IgnoreUnusedInExplicitMode,
@@ -71,16 +70,9 @@ private static void AnalyzeNamedType(SymbolAnalysisContext ctx, InterfaceCollisi
                 ctx.ReportDiagnostic(Diagnostic.Create(SingletonDiagnostics.MustBePartial, classLocation, className));
             }
 
-            var existingAwake = classSymbol.GetMembers("Awake")
-                .OfType<IMethodSymbol>()
-                .FirstOrDefault(static method => method.MethodKind == MethodKind.Ordinary
-                    && method.Parameters.Length == 0
-                    && !method.IsStatic);
-            if (existingAwake is not null)
-            {
-                var awakeLocation = existingAwake.Locations.FirstOrDefault() ?? classLocation;
-                ctx.ReportDiagnostic(Diagnostic.Create(SingletonDiagnostics.MustNotDefineAwake, awakeLocation, className));
-            }
+            // User-defined Awake() conflict is the Lifecycle analyzer's job now:
+            // [Singleton] no longer emits Awake itself — it emits a SingletonAwake
+            // helper that the lifecycle dispatcher calls.
 
             var (customInterface, _) = SingletonAttributeReader.Read(singletonAttribute);
             if (customInterface is not null)
diff --git a/src/generators-src/EngineRoom.Generators/Singleton/SingletonDiagnostics.cs b/src/generators-src/EngineRoom.Generators/Singleton/SingletonDiagnostics.cs
index 958ac21..49142ef 100644
--- a/src/generators-src/EngineRoom.Generators/Singleton/SingletonDiagnostics.cs
+++ b/src/generators-src/EngineRoom.Generators/Singleton/SingletonDiagnostics.cs
@@ -22,13 +22,9 @@ internal static class SingletonDiagnostics
             defaultSeverity: DiagnosticSeverity.Error,
             isEnabledByDefault: true);
 
-        public static readonly DiagnosticDescriptor MustNotDefineAwake = new DiagnosticDescriptor(
-            id: "ERG0003",
-            title: "[Singleton] class must not define its own Awake",
-            messageFormat: "Class '{0}' is decorated with [Singleton] and must not define an Awake() method. Move that code into OnAwake() instead.",
-            category: Category,
-            defaultSeverity: DiagnosticSeverity.Error,
-            isEnabledByDefault: true);
+        // ERG0003 ("must not define Awake") retired with the lifecycle refactor —
+        // the equivalent check now lives in LifecycleAnalyzer (ERG0203). ID kept
+        // reserved so it can't be silently reused for an unrelated diagnostic.
 
         public static readonly DiagnosticDescriptor MemberMustBePublic = new DiagnosticDescriptor(
             id: "ERG0004",
diff --git a/src/generators-src/EngineRoom.Generators/Singleton/SingletonGenerator.cs b/src/generators-src/EngineRoom.Generators/Singleton/SingletonGenerator.cs
index 66ed6b9..43e9d06 100644
--- a/src/generators-src/EngineRoom.Generators/Singleton/SingletonGenerator.cs
+++ b/src/generators-src/EngineRoom.Generators/Singleton/SingletonGenerator.cs
@@ -47,16 +47,6 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 return null;
             }
 
-            var hasOwnAwake = classSymbol.GetMembers("Awake")
-                .OfType<IMethodSymbol>()
-                .Any(static method => method.MethodKind == MethodKind.Ordinary
-                    && method.Parameters.Length == 0
-                    && !method.IsStatic);
-            if (hasOwnAwake)
-            {
-                return null;
-            }
-
             var attribute = ctx.Attributes[0];
             var (customInterface, destroyOnLoad) = SingletonAttributeReader.Read(attribute);
 
diff --git a/src/generators-src/EngineRoom.Generators/Templates/Dependency/DependencyPartial.cs.txt b/src/generators-src/EngineRoom.Generators/Templates/Dependency/DependencyPartial.cs.txt
index 5d0a638..c08c7c9 100644
--- a/src/generators-src/EngineRoom.Generators/Templates/Dependency/DependencyPartial.cs.txt
+++ b/src/generators-src/EngineRoom.Generators/Templates/Dependency/DependencyPartial.cs.txt
@@ -1,10 +1,7 @@
 partial class %%ClassName%%
 {
-    private void Start()
+    private void DependencyStart()
     {
         %%Assignments%%
-        OnStart();
     }
-
-    partial void OnStart();
 }
diff --git a/src/generators-src/EngineRoom.Generators/Templates/Lifecycle/LifecyclePartial.cs.txt b/src/generators-src/EngineRoom.Generators/Templates/Lifecycle/LifecyclePartial.cs.txt
new file mode 100644
index 0000000..0708ed7
--- /dev/null
+++ b/src/generators-src/EngineRoom.Generators/Templates/Lifecycle/LifecyclePartial.cs.txt
@@ -0,0 +1,4 @@
+partial class %%ClassName%%
+{
+    %%Methods%%
+}
diff --git a/src/generators-src/EngineRoom.Generators/Templates/Singleton/SingletonPartial.cs.txt b/src/generators-src/EngineRoom.Generators/Templates/Singleton/SingletonPartial.cs.txt
index d6b9156..91297b4 100644
--- a/src/generators-src/EngineRoom.Generators/Templates/Singleton/SingletonPartial.cs.txt
+++ b/src/generators-src/EngineRoom.Generators/Templates/Singleton/SingletonPartial.cs.txt
@@ -5,20 +5,18 @@ partial class %%ClassName%%%%BaseList%%
         var obj = new global::UnityEngine.GameObject(nameof(%%ClassName%%));
         return obj.AddComponent<%%ClassName%%>();
     }
-    
-    private void Awake()
+
+    private bool SingletonAwake()
     {
         var existing = %%InterfaceName%%.Instance as global::UnityEngine.Object;
         if (existing != null && existing != this)
         {
             global::UnityEngine.Object.Destroy(gameObject);
-            return;
+            return false;
         }
 
         %%DontDestroyLine%%
         %%InterfaceName%%.Instance = this;
-        OnAwake();
+        return true;
     }
-
-    partial void OnAwake();
 }
diff --git a/src/generators-unity/Assets/Demo/Lifecycle.meta b/src/generators-unity/Assets/Demo/Lifecycle.meta
new file mode 100644
index 0000000..88f56f8
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7c8533b230c3455ebd2bd1881e59a88f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Code.meta b/src/generators-unity/Assets/Demo/Lifecycle/Code.meta
new file mode 100644
index 0000000..027e0ac
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Code.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 78f08163bd494f5c940a98c580c3ad46
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Code/EngineRoom.Demo.Lifecycle.asmdef b/src/generators-unity/Assets/Demo/Lifecycle/Code/EngineRoom.Demo.Lifecycle.asmdef
new file mode 100644
index 0000000..edd0fa4
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Code/EngineRoom.Demo.Lifecycle.asmdef
@@ -0,0 +1,16 @@
+{
+    "name": "EngineRoom.Demo.Lifecycle",
+    "rootNamespace": "EngineRoom.Demo.Lifecycle",
+    "references": [
+        "EngineRoom.Generators.Runtime"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Code/EngineRoom.Demo.Lifecycle.asmdef.meta b/src/generators-unity/Assets/Demo/Lifecycle/Code/EngineRoom.Demo.Lifecycle.asmdef.meta
new file mode 100644
index 0000000..4d2c6a7
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Code/EngineRoom.Demo.Lifecycle.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d9045db595724c9f933e1c54c8a5d110
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleProbe.cs b/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleProbe.cs
new file mode 100644
index 0000000..202e87d
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleProbe.cs
@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using EngineRoom.Runtime.Lifecycle;
+using UnityEngine;
+
+namespace EngineRoom.Demo.Lifecycle
+{
+    public partial class LifecycleProbe : MonoBehaviour
+    {
+        public List<string> CallOrder { get; } = new List<string>();
+
+        [Awake]
+        private void RecordAwake()
+        {
+            CallOrder.Add("Awake");
+        }
+
+        [Start]
+        private void RecordStart()
+        {
+            CallOrder.Add("Start");
+        }
+
+        [OnEnable]
+        private void RecordOnEnable()
+        {
+            CallOrder.Add("OnEnable");
+        }
+
+        [OnDisable]
+        private void RecordOnDisable()
+        {
+            CallOrder.Add("OnDisable");
+        }
+
+        [Update]
+        private void RecordUpdate()
+        {
+            CallOrder.Add("Update");
+        }
+
+        [FixedUpdate]
+        private void RecordFixedUpdate()
+        {
+            CallOrder.Add("FixedUpdate");
+        }
+
+        [LateUpdate]
+        private void RecordLateUpdate()
+        {
+            CallOrder.Add("LateUpdate");
+        }
+
+        [OnDestroy]
+        private void RecordOnDestroy()
+        {
+            CallOrder.Add("OnDestroy");
+        }
+    }
+}
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleProbe.cs.meta b/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleProbe.cs.meta
new file mode 100644
index 0000000..419dbf1
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleProbe.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2a91050f69554a5c93f4923351ccc88b
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleSingletonProbe.cs b/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleSingletonProbe.cs
new file mode 100644
index 0000000..9802230
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleSingletonProbe.cs
@@ -0,0 +1,25 @@
+using EngineRoom.Runtime.Lifecycle;
+using EngineRoom.Runtime.Singleton;
+using UnityEngine;
+
+namespace EngineRoom.Demo.Lifecycle
+{
+    [Singleton]
+    public partial class LifecycleSingletonProbe : MonoBehaviour
+    {
+        public int UserAwakeCount { get; private set; }
+
+        public int OnAwakeCount { get; private set; }
+
+        [Awake]
+        private void UserAwake()
+        {
+            UserAwakeCount++;
+        }
+
+        partial void OnAwake()
+        {
+            OnAwakeCount++;
+        }
+    }
+}
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleSingletonProbe.cs.meta b/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleSingletonProbe.cs.meta
new file mode 100644
index 0000000..1bafd6e
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Code/LifecycleSingletonProbe.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e137e7601ecd46e08e7e83da9e17a6db
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Code/OrderedAwakeProbe.cs b/src/generators-unity/Assets/Demo/Lifecycle/Code/OrderedAwakeProbe.cs
new file mode 100644
index 0000000..2ce93fa
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Code/OrderedAwakeProbe.cs
@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using EngineRoom.Runtime.Lifecycle;
+using UnityEngine;
+
+namespace EngineRoom.Demo.Lifecycle
+{
+    public partial class OrderedAwakeProbe : MonoBehaviour
+    {
+        public List<string> CallOrder { get; } = new List<string>();
+
+        [Awake(10)]
+        private void Last()
+        {
+            CallOrder.Add("Last");
+        }
+
+        [Awake]
+        private void UnorderedFirstInSource()
+        {
+            CallOrder.Add("UnorderedFirstInSource");
+        }
+
+        [Awake(-5)]
+        private void First()
+        {
+            CallOrder.Add("First");
+        }
+
+        [Awake]
+        private void UnorderedSecondInSource()
+        {
+            CallOrder.Add("UnorderedSecondInSource");
+        }
+    }
+}
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Code/OrderedAwakeProbe.cs.meta b/src/generators-unity/Assets/Demo/Lifecycle/Code/OrderedAwakeProbe.cs.meta
new file mode 100644
index 0000000..c35e7b3
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Code/OrderedAwakeProbe.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8e334fcff36d41b192ff6c2f098a3146
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Tests.meta b/src/generators-unity/Assets/Demo/Lifecycle/Tests.meta
new file mode 100644
index 0000000..b9a5268
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Tests.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e36d1bbb1e7749cf8ba8fd02f633631f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Tests/EngineRoom.Demo.Lifecycle.Tests.asmdef b/src/generators-unity/Assets/Demo/Lifecycle/Tests/EngineRoom.Demo.Lifecycle.Tests.asmdef
new file mode 100644
index 0000000..e1143d7
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Tests/EngineRoom.Demo.Lifecycle.Tests.asmdef
@@ -0,0 +1,22 @@
+{
+    "name": "EngineRoom.Demo.Lifecycle.Tests",
+    "rootNamespace": "EngineRoom.Demo.Lifecycle.Tests",
+    "references": [
+        "EngineRoom.Demo.Lifecycle",
+        "EngineRoom.Generators.Runtime",
+        "UnityEngine.TestRunner"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Tests/EngineRoom.Demo.Lifecycle.Tests.asmdef.meta b/src/generators-unity/Assets/Demo/Lifecycle/Tests/EngineRoom.Demo.Lifecycle.Tests.asmdef.meta
new file mode 100644
index 0000000..27f6a68
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Tests/EngineRoom.Demo.Lifecycle.Tests.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e2221bf5145243f1bc3e46c36cfd190d
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Tests/LifecycleTests.cs b/src/generators-unity/Assets/Demo/Lifecycle/Tests/LifecycleTests.cs
new file mode 100644
index 0000000..95f454a
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Tests/LifecycleTests.cs
@@ -0,0 +1,142 @@
+using System.Collections;
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace EngineRoom.Demo.Lifecycle.Tests
+{
+    public class LifecycleTests
+    {
+        [UnityTest]
+        public IEnumerator OneShotCallbacks_FireExactlyOnce()
+        {
+            var probe = CreateActiveGameObject<LifecycleProbe>(out var gameObject);
+            yield return null;
+
+            probe.enabled = false;
+            Object.DestroyImmediate(gameObject);
+
+            Assert.AreEqual(1, probe.CallOrder.Count(name => name == "Awake"));
+            Assert.AreEqual(1, probe.CallOrder.Count(name => name == "Start"));
+            Assert.AreEqual(1, probe.CallOrder.Count(name => name == "OnEnable"));
+            Assert.AreEqual(1, probe.CallOrder.Count(name => name == "OnDisable"));
+            Assert.AreEqual(1, probe.CallOrder.Count(name => name == "OnDestroy"));
+        }
+
+        [UnityTest]
+        public IEnumerator Update_FiresEveryFrame()
+        {
+            var probe = CreateActiveGameObject<LifecycleProbe>(out var gameObject);
+            try
+            {
+                yield return null;
+                yield return null;
+
+                Assert.GreaterOrEqual(probe.CallOrder.Count(name => name == "Update"), 2);
+            }
+            finally
+            {
+                Object.DestroyImmediate(gameObject);
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator LateUpdate_FiresEveryFrame()
+        {
+            var probe = CreateActiveGameObject<LifecycleProbe>(out var gameObject);
+            try
+            {
+                yield return null;
+                yield return null;
+
+                Assert.GreaterOrEqual(probe.CallOrder.Count(name => name == "LateUpdate"), 2);
+            }
+            finally
+            {
+                Object.DestroyImmediate(gameObject);
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator FixedUpdate_FiresOnPhysicsStep()
+        {
+            var probe = CreateActiveGameObject<LifecycleProbe>(out var gameObject);
+            try
+            {
+                yield return new WaitForFixedUpdate();
+                yield return new WaitForFixedUpdate();
+
+                Assert.GreaterOrEqual(probe.CallOrder.Count(name => name == "FixedUpdate"), 1);
+            }
+            finally
+            {
+                Object.DestroyImmediate(gameObject);
+            }
+        }
+
+        [Test]
+        public void OrderedAwake_SortsByExplicitOrderThenSourcePosition()
+        {
+            var probe = CreateActiveGameObject<OrderedAwakeProbe>(out var gameObject);
+            try
+            {
+                Assert.AreEqual(
+                    new[] { "First", "UnorderedFirstInSource", "UnorderedSecondInSource", "Last" },
+                    probe.CallOrder.ToArray());
+            }
+            finally
+            {
+                Object.DestroyImmediate(gameObject);
+            }
+        }
+
+        [Test]
+        public void SingletonAwake_RunsBeforeUserAwakeAndOnAwake()
+        {
+            var probe = CreateActiveGameObject<LifecycleSingletonProbe>(out var gameObject);
+            try
+            {
+                Assert.AreSame(probe, ILifecycleSingletonProbe.Instance);
+                Assert.AreEqual(1, probe.UserAwakeCount);
+                Assert.AreEqual(1, probe.OnAwakeCount);
+            }
+            finally
+            {
+                Object.DestroyImmediate(gameObject);
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator DuplicateSingleton_AbortsBeforeUserAwakeRuns()
+        {
+            var original = CreateActiveGameObject<LifecycleSingletonProbe>(out var originalGameObject);
+            yield return null;
+
+            var duplicate = CreateActiveGameObject<LifecycleSingletonProbe>(out var duplicateGameObject);
+            try
+            {
+                Assert.AreEqual(0, duplicate.UserAwakeCount);
+                Assert.AreEqual(0, duplicate.OnAwakeCount);
+                Assert.AreSame(original, ILifecycleSingletonProbe.Instance);
+            }
+            finally
+            {
+                if (duplicateGameObject != null)
+                {
+                    Object.DestroyImmediate(duplicateGameObject);
+                }
+                if (originalGameObject != null)
+                {
+                    Object.DestroyImmediate(originalGameObject);
+                }
+            }
+        }
+
+        private static TComponent CreateActiveGameObject<TComponent>(out GameObject gameObject) where TComponent : Component
+        {
+            gameObject = new GameObject(typeof(TComponent).Name);
+            return gameObject.AddComponent<TComponent>();
+        }
+    }
+}
diff --git a/src/generators-unity/Assets/Demo/Lifecycle/Tests/LifecycleTests.cs.meta b/src/generators-unity/Assets/Demo/Lifecycle/Tests/LifecycleTests.cs.meta
new file mode 100644
index 0000000..249feca
--- /dev/null
+++ b/src/generators-unity/Assets/Demo/Lifecycle/Tests/LifecycleTests.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 90402e450e2c4fc5aa3b2163d11f95ff
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle.meta b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle.meta
new file mode 100644
index 0000000..806c54a
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 28ebb92eae8c4a2b95ac75ac6a0b322b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes.meta b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes.meta
new file mode 100644
index 0000000..d517f6f
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2f24c612436a4c12adf5bd563bc7ca6f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/AwakeAttribute.cs b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/AwakeAttribute.cs
new file mode 100644
index 0000000..fcff689
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/AwakeAttribute.cs
@@ -0,0 +1,26 @@
+using System;
+
+namespace EngineRoom.Runtime.Lifecycle
+{
+    /// <summary>
+    /// Marks a method on a MonoBehaviour to be invoked during the generated
+    /// <c>Awake</c> dispatcher. Methods without an explicit <paramref name="order"/>
+    /// run in the order they're declared in the class; methods with one are sorted
+    /// by ascending order. <c>[Singleton]</c> initialization always runs first
+    /// regardless of order.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method)]
+    public sealed class AwakeAttribute : Attribute
+    {
+        public int Order { get; }
+
+        public AwakeAttribute()
+        {
+        }
+
+        public AwakeAttribute(int order)
+        {
+            Order = order;
+        }
+    }
+}
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/AwakeAttribute.cs.meta b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/AwakeAttribute.cs.meta
new file mode 100644
index 0000000..64da75a
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/AwakeAttribute.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: bbc2bc1787fd4b5989b81f6c61877ab5
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/FixedUpdateAttribute.cs b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/FixedUpdateAttribute.cs
new file mode 100644
index 0000000..15b3a68
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/FixedUpdateAttribute.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace EngineRoom.Runtime.Lifecycle
+{
+    /// <summary>
+    /// Marks a method on a MonoBehaviour to be invoked during the generated
+    /// <c>FixedUpdate</c> dispatcher. Methods without an explicit <paramref name="order"/>
+    /// run in the order they're declared in the class; methods with one are sorted
+    /// by ascending order.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method)]
+    public sealed class FixedUpdateAttribute : Attribute
+    {
+        public int Order { get; }
+
+        public FixedUpdateAttribute()
+        {
+        }
+
+        public FixedUpdateAttribute(int order)
+        {
+            Order = order;
+        }
+    }
+}
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/FixedUpdateAttribute.cs.meta b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/FixedUpdateAttribute.cs.meta
new file mode 100644
index 0000000..18f40a9
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/FixedUpdateAttribute.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: ce6c57e5abe84940970d6d86ce505e12
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/LateUpdateAttribute.cs b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/LateUpdateAttribute.cs
new file mode 100644
index 0000000..eeeaf24
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/LateUpdateAttribute.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace EngineRoom.Runtime.Lifecycle
+{
+    /// <summary>
+    /// Marks a method on a MonoBehaviour to be invoked during the generated
+    /// <c>LateUpdate</c> dispatcher. Methods without an explicit <paramref name="order"/>
+    /// run in the order they're declared in the class; methods with one are sorted
+    /// by ascending order.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method)]
+    public sealed class LateUpdateAttribute : Attribute
+    {
+        public int Order { get; }
+
+        public LateUpdateAttribute()
+        {
+        }
+
+        public LateUpdateAttribute(int order)
+        {
+            Order = order;
+        }
+    }
+}
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/LateUpdateAttribute.cs.meta b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/LateUpdateAttribute.cs.meta
new file mode 100644
index 0000000..83aeaf6
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/LateUpdateAttribute.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1d041e8b1b7b4ff6b6b3fceb85c4371f
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDestroyAttribute.cs b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDestroyAttribute.cs
new file mode 100644
index 0000000..562877f
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDestroyAttribute.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace EngineRoom.Runtime.Lifecycle
+{
+    /// <summary>
+    /// Marks a method on a MonoBehaviour to be invoked during the generated
+    /// <c>OnDestroy</c> dispatcher. Methods without an explicit <paramref name="order"/>
+    /// run in the order they're declared in the class; methods with one are sorted
+    /// by ascending order.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method)]
+    public sealed class OnDestroyAttribute : Attribute
+    {
+        public int Order { get; }
+
+        public OnDestroyAttribute()
+        {
+        }
+
+        public OnDestroyAttribute(int order)
+        {
+            Order = order;
+        }
+    }
+}
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDestroyAttribute.cs.meta b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDestroyAttribute.cs.meta
new file mode 100644
index 0000000..1ea932b
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDestroyAttribute.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 566d6453506d44efa2abce1dd1886f20
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDisableAttribute.cs b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDisableAttribute.cs
new file mode 100644
index 0000000..d75c69c
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDisableAttribute.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace EngineRoom.Runtime.Lifecycle
+{
+    /// <summary>
+    /// Marks a method on a MonoBehaviour to be invoked during the generated
+    /// <c>OnDisable</c> dispatcher. Methods without an explicit <paramref name="order"/>
+    /// run in the order they're declared in the class; methods with one are sorted
+    /// by ascending order.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method)]
+    public sealed class OnDisableAttribute : Attribute
+    {
+        public int Order { get; }
+
+        public OnDisableAttribute()
+        {
+        }
+
+        public OnDisableAttribute(int order)
+        {
+            Order = order;
+        }
+    }
+}
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDisableAttribute.cs.meta b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDisableAttribute.cs.meta
new file mode 100644
index 0000000..a20636f
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnDisableAttribute.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d65328f07656417ab6af69ef7df6b4b5
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnEnableAttribute.cs b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnEnableAttribute.cs
new file mode 100644
index 0000000..c4c0e66
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnEnableAttribute.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace EngineRoom.Runtime.Lifecycle
+{
+    /// <summary>
+    /// Marks a method on a MonoBehaviour to be invoked during the generated
+    /// <c>OnEnable</c> dispatcher. Methods without an explicit <paramref name="order"/>
+    /// run in the order they're declared in the class; methods with one are sorted
+    /// by ascending order.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method)]
+    public sealed class OnEnableAttribute : Attribute
+    {
+        public int Order { get; }
+
+        public OnEnableAttribute()
+        {
+        }
+
+        public OnEnableAttribute(int order)
+        {
+            Order = order;
+        }
+    }
+}
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnEnableAttribute.cs.meta b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnEnableAttribute.cs.meta
new file mode 100644
index 0000000..ac30570
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/OnEnableAttribute.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1a5ea10c697b4a5cb4c8a5a293c2c5e7
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/StartAttribute.cs b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/StartAttribute.cs
new file mode 100644
index 0000000..0ad0e9c
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/StartAttribute.cs
@@ -0,0 +1,26 @@
+using System;
+
+namespace EngineRoom.Runtime.Lifecycle
+{
+    /// <summary>
+    /// Marks a method on a MonoBehaviour to be invoked during the generated
+    /// <c>Start</c> dispatcher. Methods without an explicit <paramref name="order"/>
+    /// run in the order they're declared in the class; methods with one are sorted
+    /// by ascending order. <c>[Dependency]</c> field resolution always runs first
+    /// regardless of order.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method)]
+    public sealed class StartAttribute : Attribute
+    {
+        public int Order { get; }
+
+        public StartAttribute()
+        {
+        }
+
+        public StartAttribute(int order)
+        {
+            Order = order;
+        }
+    }
+}
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/StartAttribute.cs.meta b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/StartAttribute.cs.meta
new file mode 100644
index 0000000..a573448
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/StartAttribute.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 62604f8e23354aa78f63694abb2658bf
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/UpdateAttribute.cs b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/UpdateAttribute.cs
new file mode 100644
index 0000000..19a8382
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/UpdateAttribute.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace EngineRoom.Runtime.Lifecycle
+{
+    /// <summary>
+    /// Marks a method on a MonoBehaviour to be invoked during the generated
+    /// <c>Update</c> dispatcher. Methods without an explicit <paramref name="order"/>
+    /// run in the order they're declared in the class; methods with one are sorted
+    /// by ascending order.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method)]
+    public sealed class UpdateAttribute : Attribute
+    {
+        public int Order { get; }
+
+        public UpdateAttribute()
+        {
+        }
+
+        public UpdateAttribute(int order)
+        {
+            Order = order;
+        }
+    }
+}
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/UpdateAttribute.cs.meta b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/UpdateAttribute.cs.meta
new file mode 100644
index 0000000..920db39
--- /dev/null
+++ b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Lifecycle/Attributes/UpdateAttribute.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: dd86ea960f32493e9d2f57a0b174e218
diff --git a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Plugins/EngineRoom.Generators.dll b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Plugins/EngineRoom.Generators.dll
index 6460a01..6b0391b 100644
Binary files a/src/generators-unity/Packages/games.engine-room.generators/Runtime/Plugins/EngineRoom.Generators.dll and b/src/generators-unity/Packages/games.engine-room.generators/Runtime/Plugins/EngineRoom.Generators.dll differ