diff --git a/src/ZB.MOM.WW.ScadaBridge.Commons/Interfaces/Repositories/ITemplateEngineRepository.cs b/src/ZB.MOM.WW.ScadaBridge.Commons/Interfaces/Repositories/ITemplateEngineRepository.cs
index 5cdc8c15..68146dd1 100644
--- a/src/ZB.MOM.WW.ScadaBridge.Commons/Interfaces/Repositories/ITemplateEngineRepository.cs
+++ b/src/ZB.MOM.WW.ScadaBridge.Commons/Interfaces/Repositories/ITemplateEngineRepository.cs
@@ -56,6 +56,19 @@ public interface ITemplateEngineRepository
     /// <returns>A task that resolves to a read-only list of all templates without script bodies.</returns>
     Task<IReadOnlyList<Template>> GetAllTemplatesForAnalysisAsync(CancellationToken cancellationToken = default);
     /// <summary>
+    /// Returns the same untracked, script-body-free projection as
+    /// <see cref="GetAllTemplatesForAnalysisAsync"/>, but only for the templates an analysis walk
+    /// rooted at <paramref name="templateId"/> can reach: its inheritance chain plus the
+    /// composition closure of every chain member (see
+    /// <see cref="ZB.MOM.WW.ScadaBridge.Commons.Types.Templates.TemplateAnalysisClosure"/>).
+    /// Backs member add/update validation (Gitea #66), which previously loaded every template.
+    /// Unknown ids yield an empty list.
+    /// </summary>
+    /// <param name="templateId">The template whose chain and composition closure to load.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A task that resolves to the closure templates without script bodies.</returns>
+    Task<IReadOnlyList<Template>> GetTemplateAnalysisClosureAsync(int templateId, CancellationToken cancellationToken = default);
+    /// <summary>
     /// Returns an untracked identity/edge projection of every template (no children), ordered by name.
     /// </summary>
     /// <param name="cancellationToken">Cancellation token.</param>
diff --git a/src/ZB.MOM.WW.ScadaBridge.Commons/Types/Templates/TemplateAnalysisClosure.cs b/src/ZB.MOM.WW.ScadaBridge.Commons/Types/Templates/TemplateAnalysisClosure.cs
new file mode 100644
index 00000000..11f97e76
--- /dev/null
+++ b/src/ZB.MOM.WW.ScadaBridge.Commons/Types/Templates/TemplateAnalysisClosure.cs
@@ -0,0 +1,113 @@
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
+
+namespace ZB.MOM.WW.ScadaBridge.Commons.Types.Templates;
+
+/// <summary>
+/// Computes the set of templates a member add/update analysis walk can reach from one template
+/// (Gitea #66): the template's <b>inheritance chain</b> (itself, its parent, grandparent, …) plus
+/// the <b>composition closure</b> of every chain member (each composed module, the modules they
+/// compose, and so on).
+///
+/// <para>
+/// This mirrors exactly what the analysis walkers read. <c>TemplateResolver.ResolveAllMembers</c>
+/// and <c>CollisionDetector.DetectCollisions</c> climb the parent chain of the template being
+/// analysed and descend composition edges from every chain member, but never climb a composed
+/// module's own parent chain (a derived module carries its inherited members as placeholder rows).
+/// So a composed module's ancestors are not loaded — only chain members expand their parent edge.
+/// Every other template in the library is irrelevant to the result, which is why member edits no
+/// longer need the whole analysis graph.
+/// </para>
+///
+/// <para>
+/// The walk is breadth-first by batch: each round asks <c>loadBatch</c> for every id not yet
+/// loaded, so a store-backed loader issues one query per closure depth rather than one per
+/// template. Missing ids (a dangling edge) are simply absent from the result, exactly as the
+/// walkers skip them. Cycles terminate: an id is expanded at most twice (once as a module, once
+/// more if it is later reached as a chain member).
+/// </para>
+/// </summary>
+public static class TemplateAnalysisClosure
+{
+    /// <summary>
+    /// Collects the inheritance chain and composition closure of <paramref name="templateId"/>.
+    /// </summary>
+    /// <param name="templateId">The template whose analysis closure is wanted.</param>
+    /// <param name="loadBatch">Loads the templates with the given ids (unknown ids are omitted).</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The closure templates, each once, in load order (the root first when it exists).</returns>
+    public static async Task<IReadOnlyList<Template>> CollectAsync(
+        int templateId,
+        Func<IReadOnlyCollection<int>, CancellationToken, Task<IReadOnlyList<Template>>> loadBatch,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(loadBatch);
+
+        var loaded = new Dictionary<int, Template>();
+        var result = new List<Template>();
+        var requested = new HashSet<int>();
+        // id -> true when expanded as a chain member (parent + compositions),
+        //       false when expanded as a module only (compositions).
+        var expanded = new Dictionary<int, bool>();
+        // Ids reached but not loaded yet, with "reached as chain member" OR'd in.
+        var wanted = new Dictionary<int, bool> { [templateId] = true };
+
+        while (wanted.Count > 0)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var toLoad = wanted.Keys.Where(requested.Add).ToArray();
+            if (toLoad.Length > 0)
+            {
+                var batch = await loadBatch(toLoad, cancellationToken).ConfigureAwait(false);
+                foreach (var t in batch)
+                {
+                    if (loaded.TryAdd(t.Id, t))
+                        result.Add(t);
+                }
+            }
+
+            var round = wanted.ToArray();
+            wanted.Clear();
+            foreach (var (id, asChain) in round)
+                Expand(id, asChain, loaded, expanded, wanted, requested);
+        }
+
+        return result;
+    }
+
+    private static void Expand(
+        int rootId,
+        bool rootAsChain,
+        Dictionary<int, Template> loaded,
+        Dictionary<int, bool> expanded,
+        Dictionary<int, bool> wanted,
+        HashSet<int> requested)
+    {
+        var stack = new Stack<(int Id, bool AsChain)>();
+        stack.Push((rootId, rootAsChain));
+
+        while (stack.Count > 0)
+        {
+            var (id, asChain) = stack.Pop();
+
+            if (!loaded.TryGetValue(id, out var template))
+            {
+                // Already asked the loader and it does not exist: a dangling edge, skip it.
+                if (requested.Contains(id))
+                    continue;
+                wanted[id] = asChain || (wanted.TryGetValue(id, out var w) && w);
+                continue;
+            }
+
+            if (expanded.TryGetValue(id, out var wasChain) && (wasChain || !asChain))
+                continue;
+            expanded[id] = asChain;
+
+            if (asChain && template.ParentTemplateId is int parentId)
+                stack.Push((parentId, true));
+
+            foreach (var composition in template.Compositions)
+                stack.Push((composition.ComposedTemplateId, false));
+        }
+    }
+}
diff --git a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/TemplateEngineRepository.cs b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/TemplateEngineRepository.cs
index 9d378d33..f1884cc5 100644
--- a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/TemplateEngineRepository.cs
+++ b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/TemplateEngineRepository.cs
@@ -122,8 +122,33 @@ public class TemplateEngineRepository : ITemplateEngineRepository
     // <see cref="GetAllTemplatesAsync"/> / <see cref="GetTemplateWithChildrenAsync"/>.
     public async Task<IReadOnlyList<Template>> GetAllTemplatesForAnalysisAsync(CancellationToken cancellationToken = default)
     {
-        return await _context.Templates
-            .AsNoTracking()
+        return await AnalysisProjection(_context.Templates.AsNoTracking())
+            .ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    // One projection query per closure depth (TemplateAnalysisClosure batches each frontier),
+    // each restricted to the frontier's ids — so a member edit reads its own chain and modules
+    // instead of every template, attribute, alarm and script in the library.
+    public Task<IReadOnlyList<Template>> GetTemplateAnalysisClosureAsync(int templateId, CancellationToken cancellationToken = default)
+    {
+        return TemplateAnalysisClosure.CollectAsync(
+            templateId,
+            async (ids, ct) =>
+            {
+                var idList = ids.ToList();
+                return await AnalysisProjection(_context.Templates.AsNoTracking().Where(t => idList.Contains(t.Id)))
+                    .ToListAsync(ct);
+            },
+            cancellationToken);
+    }
+
+    // The analysis projection shared by GetAllTemplatesForAnalysisAsync and
+    // GetTemplateAnalysisClosureAsync (see the note on the former for why it is untracked and
+    // drops TemplateScript.Code).
+    private static IQueryable<Template> AnalysisProjection(IQueryable<Template> source)
+    {
+        return source
             .Select(t => new Template(t.Name)
             {
                 Id = t.Id,
@@ -152,8 +177,7 @@ public class TemplateEngineRepository : ITemplateEngineRepository
                         LockedInDerived = s.LockedInDerived
                     })
                     .ToList()
-            })
-            .ToListAsync(cancellationToken);
+            });
     }
 
     /// <inheritdoc />
diff --git a/src/ZB.MOM.WW.ScadaBridge.TemplateEngine/TemplateService.cs b/src/ZB.MOM.WW.ScadaBridge.TemplateEngine/TemplateService.cs
index 6b74965d..58c514e1 100644
--- a/src/ZB.MOM.WW.ScadaBridge.TemplateEngine/TemplateService.cs
+++ b/src/ZB.MOM.WW.ScadaBridge.TemplateEngine/TemplateService.cs
@@ -311,7 +311,8 @@ public class TemplateService
         attribute.TemplateId = templateId;
 
         // If inheriting, validate not trying to add a member that would collide
-        var allTemplates = await _repository.GetAllTemplatesForAnalysisAsync(cancellationToken);
+        // Only the template's inheritance chain + composition closure can collide (#66).
+        var allTemplates = await _repository.GetTemplateAnalysisClosureAsync(templateId, cancellationToken);
         var testTemplate = CloneTemplateWithNewAttribute(template, attribute);
         var collisions = CollisionDetector.DetectCollisions(testTemplate, allTemplates);
         if (collisions.Count > 0)
@@ -363,7 +364,8 @@ public class TemplateService
         var template = await _repository.GetTemplateByIdAsync(existing.TemplateId, cancellationToken);
         if (template?.ParentTemplateId != null)
         {
-            var allTemplates = await _repository.GetAllTemplatesForAnalysisAsync(cancellationToken);
+            // The parent's members resolve from its chain + composition closure alone (#66).
+            var allTemplates = await _repository.GetTemplateAnalysisClosureAsync(template.ParentTemplateId.Value, cancellationToken);
             var parentMember = TemplateResolver.FindMemberByCanonicalName(
                 existing.Name, template.ParentTemplateId.Value, allTemplates);
             if (parentMember != null && parentMember.IsLocked)
@@ -548,7 +550,8 @@ public class TemplateService
         alarm.TemplateId = templateId;
 
         // Check collisions
-        var allTemplates = await _repository.GetAllTemplatesForAnalysisAsync(cancellationToken);
+        // Only the template's inheritance chain + composition closure can collide (#66).
+        var allTemplates = await _repository.GetTemplateAnalysisClosureAsync(templateId, cancellationToken);
         var testTemplate = CloneTemplateWithNewAlarm(template, alarm);
         var collisions = CollisionDetector.DetectCollisions(testTemplate, allTemplates);
         if (collisions.Count > 0)
@@ -598,7 +601,8 @@ public class TemplateService
         var template = await _repository.GetTemplateByIdAsync(existing.TemplateId, cancellationToken);
         if (template?.ParentTemplateId != null)
         {
-            var allTemplates = await _repository.GetAllTemplatesForAnalysisAsync(cancellationToken);
+            // The parent's members resolve from its chain + composition closure alone (#66).
+            var allTemplates = await _repository.GetTemplateAnalysisClosureAsync(template.ParentTemplateId.Value, cancellationToken);
             var parentMember = TemplateResolver.FindMemberByCanonicalName(
                 existing.Name, template.ParentTemplateId.Value, allTemplates);
             if (parentMember != null && parentMember.IsLocked)
@@ -723,7 +727,8 @@ public class TemplateService
         script.TemplateId = templateId;
 
         // Check collisions
-        var allTemplates = await _repository.GetAllTemplatesForAnalysisAsync(cancellationToken);
+        // Only the template's inheritance chain + composition closure can collide (#66).
+        var allTemplates = await _repository.GetTemplateAnalysisClosureAsync(templateId, cancellationToken);
         var testTemplate = CloneTemplateWithNewScript(template, script);
         var collisions = CollisionDetector.DetectCollisions(testTemplate, allTemplates);
         if (collisions.Count > 0)
@@ -770,7 +775,8 @@ public class TemplateService
         var template = await _repository.GetTemplateByIdAsync(existing.TemplateId, cancellationToken);
         if (template?.ParentTemplateId != null)
         {
-            var allTemplates = await _repository.GetAllTemplatesForAnalysisAsync(cancellationToken);
+            // The parent's members resolve from its chain + composition closure alone (#66).
+            var allTemplates = await _repository.GetTemplateAnalysisClosureAsync(template.ParentTemplateId.Value, cancellationToken);
             var parentMember = TemplateResolver.FindMemberByCanonicalName(
                 existing.Name, template.ParentTemplateId.Value, allTemplates);
             if (parentMember != null && parentMember.IsLocked)
diff --git a/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/TemplateAnalysisClosureRepositoryTests.cs b/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/TemplateAnalysisClosureRepositoryTests.cs
new file mode 100644
index 00000000..73e1d182
--- /dev/null
+++ b/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/TemplateAnalysisClosureRepositoryTests.cs
@@ -0,0 +1,126 @@
+using Microsoft.EntityFrameworkCore;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Templates;
+using ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Repositories;
+
+namespace ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests;
+
+/// <summary>
+/// Gitea #66: <see cref="TemplateEngineRepository.GetTemplateAnalysisClosureAsync"/> reads only a
+/// template's inheritance chain + composition closure — one projection query per closure depth —
+/// instead of the whole library that <see cref="TemplateEngineRepository.GetAllTemplatesForAnalysisAsync"/>
+/// materialises. Asserted against real SQL on SQLite with the reader commands recorded.
+/// </summary>
+public class TemplateAnalysisClosureRepositoryTests : IDisposable
+{
+    private const int UnrelatedTemplates = 40;
+    private const string BigBody = "/* script body that must never be read by analysis */";
+
+    private readonly SqlReaderCommandRecorder _recorder = new();
+    private readonly ScadaBridgeDbContext _context;
+    private readonly TemplateEngineRepository _repository;
+
+    /// <summary>Initializes the test class with an in-memory context and repository.</summary>
+    public TemplateAnalysisClosureRepositoryTests()
+    {
+        _context = SqliteTestHelper.CreateInMemoryContext(_recorder);
+        _repository = new TemplateEngineRepository(_context, new TemplateGraphWatermark());
+    }
+
+    /// <summary>Releases the resources held by this test class.</summary>
+    public void Dispose()
+    {
+        _context.Database.CloseConnection();
+        _context.Dispose();
+    }
+
+    private async Task<Template> AddAsync(string name, int? parentId = null)
+    {
+        var t = new Template(name) { ParentTemplateId = parentId };
+        t.Attributes.Add(new TemplateAttribute($"{name}Attr1"));
+        t.Attributes.Add(new TemplateAttribute($"{name}Attr2"));
+        t.Scripts.Add(new TemplateScript($"{name}Script", BigBody));
+        _context.Templates.Add(t);
+        await _context.SaveChangesAsync();
+        return t;
+    }
+
+    private async Task ComposeAsync(Template owner, Template module, string slot)
+    {
+        _context.Set<TemplateComposition>().Add(
+            new TemplateComposition(slot) { TemplateId = owner.Id, ComposedTemplateId = module.Id });
+        await _context.SaveChangesAsync();
+    }
+
+    private sealed record Seeded(int Grand, int Parent, int Child, int ModA, int ModB, int ModBBase, int Inner);
+
+    private async Task<Seeded> SeedAsync()
+    {
+        var grand = await AddAsync("Grand");
+        var parent = await AddAsync("Parent", grand.Id);
+        var child = await AddAsync("Child", parent.Id);
+        var modBBase = await AddAsync("ModBBase");
+        var modB = await AddAsync("ModB", modBBase.Id);
+        var modA = await AddAsync("ModA");
+        var inner = await AddAsync("Inner");
+        await ComposeAsync(parent, modA, "m1");
+        await ComposeAsync(child, modB, "m2");
+        await ComposeAsync(modA, inner, "inner");
+
+        for (var i = 0; i < UnrelatedTemplates; i++)
+            await AddAsync($"Unrelated{i}");
+
+        _context.ChangeTracker.Clear();
+        _recorder.Reset();
+        return new Seeded(grand.Id, parent.Id, child.Id, modA.Id, modB.Id, modBBase.Id, inner.Id);
+    }
+
+    /// <summary>
+    /// The closure is exactly the chain + composition closure, loaded untracked without script
+    /// bodies, in one query per depth — against 47 templates for the whole-graph load.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task Closure_ReadsOnlyChainAndCompositionClosure_OneQueryPerDepth()
+    {
+        var ids = await SeedAsync();
+
+        var whole = await _repository.GetAllTemplatesForAnalysisAsync();
+        var wholeQueries = _recorder.Commands.Count;
+        _recorder.Reset();
+
+        var closure = await _repository.GetTemplateAnalysisClosureAsync(ids.Child);
+        var closureQueries = _recorder.Commands.Count;
+
+        // Entity count: 6 templates / 12 attributes instead of 47 / 94.
+        Assert.Equal(
+            new[] { ids.Grand, ids.Parent, ids.Child, ids.ModA, ids.ModB, ids.Inner }.OrderBy(i => i),
+            closure.Select(t => t.Id).OrderBy(i => i));
+        Assert.Equal(7 + UnrelatedTemplates, whole.Count);
+        Assert.Equal(12, closure.Sum(t => t.Attributes.Count));
+        Assert.Equal(2 * (7 + UnrelatedTemplates), whole.Sum(t => t.Attributes.Count));
+
+        // Query count: one projection query per depth (Child; Parent+ModB; Grand+ModA; Inner).
+        Assert.Equal(4 * wholeQueries, closureQueries);
+
+        // Same analysis shape as the whole-graph load: untracked, no script bodies, edges present.
+        Assert.Empty(_context.ChangeTracker.Entries());
+        Assert.All(closure.SelectMany(t => t.Scripts), s => Assert.Equal(string.Empty, s.Code));
+        Assert.False(_recorder.AnySelectReads("\"Code\""));
+        Assert.Single(closure.Single(t => t.Id == ids.Child).Compositions);
+
+        // Positive control: the body column IS visible to the recorder when a load reads it.
+        _recorder.Reset();
+        await _repository.GetAllTemplatesAsync();
+        Assert.True(_recorder.AnySelectReads("\"Code\""));
+    }
+
+    /// <summary>An unknown id loads nothing beyond the single probe query.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task Closure_UnknownTemplate_IsEmpty()
+    {
+        await SeedAsync();
+        Assert.Empty(await _repository.GetTemplateAnalysisClosureAsync(987654));
+    }
+}
diff --git a/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/AnalysisClosureMock.cs b/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/AnalysisClosureMock.cs
new file mode 100644
index 00000000..61db7f66
--- /dev/null
+++ b/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/AnalysisClosureMock.cs
@@ -0,0 +1,40 @@
+using Moq;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
+using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Templates;
+
+namespace ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests;
+
+/// <summary>
+/// Gitea #66: member add/update now asks the repository for a template's analysis closure
+/// rather than the whole analysis graph. Test classes keep seeding the whole graph through
+/// <c>GetAllTemplatesForAnalysisAsync</c>; this wires <c>GetTemplateAnalysisClosureAsync</c>
+/// to serve the real closure walk over that seeded graph, so every existing scenario runs the
+/// service against the reduced set — the same set the production repository returns.
+/// </summary>
+internal static class AnalysisClosureMock
+{
+    /// <summary>Wires the closure method to filter whatever the full-graph setup returns.</summary>
+    /// <param name="repoMock">The repository mock.</param>
+    /// <param name="closureRequests">Optional sink recording each requested closure root.</param>
+    public static void ServeClosureFromFullGraph(
+        this Mock<ITemplateEngineRepository> repoMock,
+        List<int>? closureRequests = null)
+    {
+        repoMock
+            .Setup(r => r.GetTemplateAnalysisClosureAsync(It.IsAny<int>(), It.IsAny<CancellationToken>()))
+            .Returns((int templateId, CancellationToken ct) =>
+            {
+                closureRequests?.Add(templateId);
+                return TemplateAnalysisClosure.CollectAsync(
+                    templateId,
+                    async (ids, token) =>
+                    {
+                        var all = await repoMock.Object.GetAllTemplatesForAnalysisAsync(token)
+                                  ?? Array.Empty<Template>();
+                        return all.Where(t => ids.Contains(t.Id)).ToList();
+                    },
+                    ct);
+            });
+    }
+}
diff --git a/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateAnalysisClosureTests.cs b/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateAnalysisClosureTests.cs
new file mode 100644
index 00000000..529d77d6
--- /dev/null
+++ b/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateAnalysisClosureTests.cs
@@ -0,0 +1,162 @@
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Templates;
+
+namespace ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests;
+
+/// <summary>
+/// Gitea #66: member add/update validation now runs the analysis walkers over a template's
+/// inheritance chain + composition closure instead of the whole library. These tests pin that
+/// the closure is (a) sufficient — every walker answer is identical to the whole-graph answer,
+/// for every template in a graph with chains, nested and diamond compositions, a derived
+/// module, cycles, dangling edges and unrelated look-alikes — and (b) actually smaller.
+/// </summary>
+public class TemplateAnalysisClosureTests
+{
+    // Ids of the fixture graph.
+    private const int Grand = 1, Parent = 2, Child = 3, ModA = 4, ModB = 5, ModBBase = 6, Inner = 7;
+    private const int CycX = 8, CycY = 9, Dangling = 10;
+    private const int Twin = 18, TwinParent = 19, TwinGrand = 20;
+
+    private static readonly List<Template> Graph = BuildGraph();
+
+    private static List<Template> BuildGraph()
+    {
+        var memberId = 1000;
+        Template T(int id, string name, int? parent = null, params string[] attrs)
+        {
+            var t = new Template(name) { Id = id, ParentTemplateId = parent };
+            foreach (var a in attrs)
+                t.Attributes.Add(new TemplateAttribute(a) { Id = memberId++, TemplateId = id, IsLocked = a.StartsWith('L') });
+            return t;
+        }
+
+        void Compose(Template owner, Template module, string slot) =>
+            owner.Compositions.Add(new TemplateComposition(slot) { Id = memberId++, TemplateId = owner.Id, ComposedTemplateId = module.Id });
+
+        var grand = T(Grand, "Grand", null, "LSpeed", "Shared");
+        var parent = T(Parent, "Parent", Grand, "Flow");
+        var child = T(Child, "Child", Parent, "Shared", "m1.Level"); // overrides + a would-be collision
+        var modA = T(ModA, "ModA", null, "Level", "Temp");
+        var modB = T(ModB, "ModB", ModBBase, "Base1");                // derived module (placeholder row)
+        var modBBase = T(ModBBase, "ModBBase", null, "Base1", "OnlyInBase");
+        var inner = T(Inner, "Inner", null, "Deep");
+        modB.Alarms.Add(new TemplateAlarm("HiHi") { Id = memberId++, TemplateId = ModB });
+        modA.Scripts.Add(new TemplateScript("Calc", string.Empty) { Id = memberId++, TemplateId = ModA, IsLocked = true });
+
+        Compose(parent, modA, "m1");
+        Compose(child, modB, "m2");
+        Compose(child, modA, "m1b");        // diamond: ModA reached by two paths
+        Compose(modA, inner, "inner");
+
+        var cycX = T(CycX, "CycX", null, "X");
+        var cycY = T(CycY, "CycY", null, "Y");
+        Compose(cycX, cycY, "y");
+        Compose(cycY, cycX, "x");           // composition cycle
+
+        var dangling = T(Dangling, "Dangling", 998, "D");
+        dangling.Compositions.Add(new TemplateComposition("ghost") { Id = memberId++, TemplateId = Dangling, ComposedTemplateId = 999 });
+
+        // A template reached first as a module and then as a chain member: its parent must still load.
+        var twinGrand = T(TwinGrand, "TwinGrand", null, "G");
+        var twinParent = T(TwinParent, "TwinParent", TwinGrand, "P");
+        var twin = T(Twin, "Twin", TwinParent, "S");
+        Compose(twin, twinParent, "t");
+
+        var all = new List<Template> { grand, parent, child, modA, modB, modBBase, inner, cycX, cycY, dangling, twinGrand, twinParent, twin };
+
+        // Unrelated library content with colliding member names — must never be loaded.
+        for (var i = 0; i < 5; i++)
+            all.Add(T(11 + i, $"Unrelated{i}", i == 0 ? null : 11, "Shared", "Level", "m1.Level"));
+
+        return all;
+    }
+
+    private static Task<IReadOnlyList<Template>> InMemoryClosure(int id, List<IReadOnlyCollection<int>>? batches = null) =>
+        TemplateAnalysisClosure.CollectAsync(id, (ids, _) =>
+        {
+            batches?.Add(ids);
+            return Task.FromResult<IReadOnlyList<Template>>(Graph.Where(t => ids.Contains(t.Id)).ToList());
+        });
+
+    public static IEnumerable<object[]> EveryTemplate() => Graph.Select(t => new object[] { t.Id });
+
+    /// <summary>Resolver and collision detector give the same answer from the closure as from the whole graph.</summary>
+    /// <param name="templateId">Template under analysis.</param>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Theory]
+    [MemberData(nameof(EveryTemplate))]
+    public async Task Walkers_AnswerIdenticallyFromClosure(int templateId)
+    {
+        var closure = await InMemoryClosure(templateId);
+        var template = Graph.Single(t => t.Id == templateId);
+
+        Assert.Equal(
+            TemplateResolver.ResolveAllMembers(templateId, Graph),
+            TemplateResolver.ResolveAllMembers(templateId, closure));
+        Assert.Equal(
+            CollisionDetector.DetectCollisions(template, Graph),
+            CollisionDetector.DetectCollisions(template, closure));
+
+        foreach (var member in TemplateResolver.ResolveAllMembers(templateId, Graph))
+        {
+            Assert.Equal(
+                TemplateResolver.FindMemberByCanonicalName(member.CanonicalName, templateId, Graph),
+                TemplateResolver.FindMemberByCanonicalName(member.CanonicalName, templateId, closure));
+        }
+    }
+
+    /// <summary>The fixture really exercises a collision, so the equality above is not vacuous.</summary>
+    [Fact]
+    public void Fixture_ChildHasACompositionCollision()
+    {
+        var child = Graph.Single(t => t.Id == Child);
+        Assert.NotEmpty(CollisionDetector.DetectCollisions(child, Graph));
+    }
+
+    /// <summary>The closure is exactly the chain plus composition closure — no module ancestors, no unrelated templates.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task Closure_IsChainPlusCompositionClosureOnly()
+    {
+        var closure = await InMemoryClosure(Child);
+
+        Assert.Equal(
+            new[] { Grand, Parent, Child, ModA, ModB, Inner }.OrderBy(i => i),
+            closure.Select(t => t.Id).OrderBy(i => i));
+        Assert.DoesNotContain(closure, t => t.Id == ModBBase); // a module's parent chain is never walked
+        Assert.True(closure.Count < Graph.Count);
+    }
+
+    /// <summary>A template reached as a module before it is reached as a chain member still expands its parent.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task Closure_ModuleThatIsAlsoAChainMember_StillClimbsItsParent()
+    {
+        var closure = await InMemoryClosure(Twin);
+        Assert.Equal(new[] { Twin, TwinParent, TwinGrand }.OrderBy(i => i), closure.Select(t => t.Id).OrderBy(i => i));
+    }
+
+    /// <summary>Cycles terminate and dangling ids are skipped.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task Closure_TerminatesOnCyclesAndSkipsDanglingEdges()
+    {
+        Assert.Equal(new[] { CycX, CycY }, (await InMemoryClosure(CycX)).Select(t => t.Id).OrderBy(i => i));
+        Assert.Equal(new[] { Dangling }, (await InMemoryClosure(Dangling)).Select(t => t.Id));
+        Assert.Empty(await InMemoryClosure(424242));
+    }
+
+    /// <summary>One batch per closure depth, and no id is ever requested twice.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task Closure_LoadsOneBatchPerDepth_NeverRequestsAnIdTwice()
+    {
+        var batches = new List<IReadOnlyCollection<int>>();
+        await InMemoryClosure(Child, batches);
+
+        // Depth 0: Child; depth 1: Parent, ModB, ModA; depth 2: Grand, Inner.
+        Assert.Equal(3, batches.Count);
+        var requested = batches.SelectMany(b => b).ToList();
+        Assert.Equal(requested.Count, requested.Distinct().Count());
+    }
+}
diff --git a/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateAuditShapeTests.cs b/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateAuditShapeTests.cs
index 27df44cf..9caa4be1 100644
--- a/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateAuditShapeTests.cs
+++ b/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateAuditShapeTests.cs
@@ -23,6 +23,7 @@ public class TemplateAuditShapeTests
     public TemplateAuditShapeTests()
     {
         _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>())).ReturnsAsync(1);
+        _repoMock.ServeClosureFromFullGraph();
         _auditMock
             .Setup(a => a.LogAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
                 It.IsAny<string>(), It.IsAny<string>(), It.IsAny<object?>(), It.IsAny<CancellationToken>()))
diff --git a/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateServiceTests.cs b/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateServiceTests.cs
index 3f45fb2c..3c1a3845 100644
--- a/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateServiceTests.cs
+++ b/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateServiceTests.cs
@@ -13,6 +13,7 @@ public class TemplateServiceTests
     private readonly Mock<ITemplateEngineRepository> _repoMock;
     private readonly Mock<IAuditService> _auditMock;
     private readonly TemplateService _service;
+    private readonly List<int> _closureRequests = new();
 
     /// <summary>Initializes the test with mocked repositories and the service under test.</summary>
     public TemplateServiceTests()
@@ -20,6 +21,7 @@ public class TemplateServiceTests
         _repoMock = new Mock<ITemplateEngineRepository>();
         _auditMock = new Mock<IAuditService>();
         _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>())).ReturnsAsync(1);
+        _repoMock.ServeClosureFromFullGraph(_closureRequests);
         _service = new TemplateService(_repoMock.Object, _auditMock.Object);
     }
 
@@ -2319,4 +2321,88 @@ public class TemplateServiceTests
         Assert.True(propagated.IsInherited);
         Assert.True(propagated.IsMesReportable);
     }
+
+    // ========================================================================
+    // Gitea #66: member add/update loads only the analysis closure
+    // ========================================================================
+
+    private void WholeAnalysisGraphMustNotLoad() =>
+        _repoMock.Setup(r => r.GetAllTemplatesForAnalysisAsync(It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new InvalidOperationException("member add/update loaded the whole analysis graph"));
+
+    /// <summary>
+    /// Member adds validate collisions against the template's own closure (here: itself plus
+    /// its composed module) and never touch the whole-library analysis graph.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task MemberAdds_CheckCollisionsAgainstClosure_NeverLoadWholeGraph()
+    {
+        var module = new Template("Motor") { Id = 2 };
+        module.Attributes.Add(new TemplateAttribute("Temp") { Id = 20, TemplateId = 2 });
+        var template = new Template("Pump") { Id = 1 };
+        template.Compositions.Add(new TemplateComposition("m") { Id = 5, TemplateId = 1, ComposedTemplateId = 2 });
+
+        _repoMock.Setup(r => r.GetTemplateByIdAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(template);
+        _repoMock.Setup(r => r.GetAllTemplatesAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<Template> { template, module });
+        _repoMock.Setup(r => r.GetTemplateAnalysisClosureAsync(1, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<Template> { template, module });
+        WholeAnalysisGraphMustNotLoad();
+
+        // A canonical-name collision with the composed module is still caught from the closure.
+        var colliding = await _service.AddAttributeAsync(
+            1, new TemplateAttribute("m.Temp") { DataType = DataType.Float, Value = "0" }, "admin");
+        Assert.True(colliding.IsFailure);
+        Assert.Contains("Naming collision on 'm.Temp'", colliding.Error);
+
+        Assert.True((await _service.AddAttributeAsync(
+            1, new TemplateAttribute("Speed") { DataType = DataType.Float, Value = "0" }, "admin")).IsSuccess);
+        Assert.True((await _service.AddAlarmAsync(
+            1, new TemplateAlarm("Hi") { PriorityLevel = 500, TriggerType = AlarmTriggerType.ValueMatch }, "admin")).IsSuccess);
+        Assert.True((await _service.AddScriptAsync(
+            1, new TemplateScript("OnStart", "return true;") { TriggerType = "Startup" }, "admin")).IsSuccess);
+
+        _repoMock.Verify(r => r.GetTemplateAnalysisClosureAsync(1, It.IsAny<CancellationToken>()), Times.Exactly(4));
+        _repoMock.Verify(r => r.GetAllTemplatesForAnalysisAsync(It.IsAny<CancellationToken>()), Times.Never);
+    }
+
+    /// <summary>
+    /// Member updates resolve the parent lock from the PARENT's closure: a member locked on the
+    /// grandparent is found through the chain without loading the whole graph.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task MemberUpdates_ResolveParentLockFromParentClosure_NeverLoadWholeGraph()
+    {
+        var grand = new Template("Grand") { Id = 1 };
+        grand.Attributes.Add(new TemplateAttribute("Speed") { Id = 10, TemplateId = 1, DataType = DataType.Float, IsLocked = true });
+        grand.Alarms.Add(new TemplateAlarm("Hi") { Id = 11, TemplateId = 1, IsLocked = true, TriggerType = AlarmTriggerType.ValueMatch });
+        grand.Scripts.Add(new TemplateScript("Calc", string.Empty) { Id = 12, TemplateId = 1, IsLocked = true });
+        var parent = new Template("Parent") { Id = 2, ParentTemplateId = 1 };
+        var child = new Template("Child") { Id = 3, ParentTemplateId = 2 };
+        var childAttr = new TemplateAttribute("Speed") { Id = 30, TemplateId = 3, DataType = DataType.Float };
+        var childAlarm = new TemplateAlarm("Hi") { Id = 31, TemplateId = 3, TriggerType = AlarmTriggerType.ValueMatch };
+        var childScript = new TemplateScript("Calc", "return 1;") { Id = 32, TemplateId = 3 };
+
+        _repoMock.Setup(r => r.GetTemplateAttributeByIdAsync(30, It.IsAny<CancellationToken>())).ReturnsAsync(childAttr);
+        _repoMock.Setup(r => r.GetTemplateAlarmByIdAsync(31, It.IsAny<CancellationToken>())).ReturnsAsync(childAlarm);
+        _repoMock.Setup(r => r.GetTemplateScriptByIdAsync(32, It.IsAny<CancellationToken>())).ReturnsAsync(childScript);
+        _repoMock.Setup(r => r.GetTemplateByIdAsync(3, It.IsAny<CancellationToken>())).ReturnsAsync(child);
+        _repoMock.Setup(r => r.GetTemplateAnalysisClosureAsync(2, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<Template> { parent, grand });
+        WholeAnalysisGraphMustNotLoad();
+
+        var attr = await _service.UpdateAttributeAsync(
+            30, new TemplateAttribute("Speed") { DataType = DataType.Float, Value = "1" }, "admin");
+        var alarm = await _service.UpdateAlarmAsync(
+            31, new TemplateAlarm("Hi") { TriggerType = AlarmTriggerType.ValueMatch }, "admin");
+        var script = await _service.UpdateScriptAsync(32, new TemplateScript("Calc", "return 2;"), "admin");
+
+        Assert.Contains("locked in parent", attr.Error);
+        Assert.Contains("locked in parent", alarm.Error);
+        Assert.Contains("locked in parent", script.Error);
+        _repoMock.Verify(r => r.GetTemplateAnalysisClosureAsync(2, It.IsAny<CancellationToken>()), Times.Exactly(3));
+        _repoMock.Verify(r => r.GetAllTemplatesForAnalysisAsync(It.IsAny<CancellationToken>()), Times.Never);
+    }
 }