fix: Improve pipeline context isolation and thread safety (#1449)

* chore: Add .worktrees/ to .gitignore for parallel development

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

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

* fix: Improve pipeline context isolation and thread safety (#1417)

This PR addresses issue #1417 by implementing proper module-scoped isolation:

**Breaking Changes:**
- `IEnvironmentContext.ContentDirectory` and `WorkingDirectory` are now readonly
  (changed from `{ get; set; }` to `{ get; }`)

**Improvements:**
- Add AsyncLocal cleanup in ModuleRunner to prevent potential context leaks
- Replace `List<T>` with `ConcurrentBag<T>` in ModuleLoggerContainer for lock-free
  thread-safe operations during high-concurrency module execution
- Add documentation explaining PipelineContext scoped lifetime and logger caching safety

**Files Changed:**
- ModuleRunner.cs: Added try/finally to clear AsyncLocal logger context
- IEnvironmentContext.cs: Made ContentDirectory/WorkingDirectory readonly with docs
- EnvironmentContext.cs: Implementation matches interface changes
- PipelineContext.cs: Added XML documentation for scoped DI behavior
- ModuleLoggerContainer.cs: Replaced List+locks with ConcurrentBag+Interlocked

Closes #1417

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

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

* fix: Address code review feedback for pipeline context isolation

- Move AsyncLocal assignment inside try block to guarantee cleanup even
  if an exception occurs immediately after assignment (critical fix)
- Optimize ModuleLoggerContainer with ConcurrentDictionary for O(1)
  lookups instead of O(n) ConcurrentBag enumeration
- Document why volatile is unnecessary when using Interlocked.Exchange
  (provides full memory barrier)

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

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

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: thomhurst

src/ModularPipelines/Engine/Execution/ModuleRunner.cs

@@ -148,10 +148,11 @@ private async Task ExecuteModuleWithPipeline(ModuleState moduleState, IServicePr
         var moduleContext = new ModuleContext(pipelineContext, module, executionContext, logger);
 
         // Set up logging - use try/finally to ensure cleanup of AsyncLocal context
-        ModuleLogger.Values.Value = logger;
-
+        // Assignment MUST be inside try block to guarantee cleanup even if an exception
+        // occurs immediately after assignment
         try
         {
+            ModuleLogger.Values.Value = logger;
             await ExecuteModuleLifecycle(moduleState, scopedServiceProvider, pipelineContext, executionContext, moduleContext, cancellationToken).ConfigureAwait(false);
         }
         finally

src/ModularPipelines/Logging/ModuleLoggerContainer.cs

@@ -10,12 +10,14 @@ namespace ModularPipelines.Logging;
 /// This container tracks all module loggers created during pipeline execution
 /// and ensures they are properly flushed and disposed in the correct order
 /// (ordered by last log written time) to maintain logical output ordering.
-/// Uses ConcurrentBag for lock-free thread-safe operations during high-concurrency
-/// module execution.
+/// Uses ConcurrentDictionary for O(1) thread-safe lookups by type.
 /// </remarks>
 internal class ModuleLoggerContainer : IModuleLoggerContainer, IDisposable
 {
-    private readonly ConcurrentBag<ModuleLogger> _loggers = new();
+    private readonly ConcurrentDictionary<Type, ModuleLogger> _loggers = new();
+
+    // Interlocked.Exchange provides both atomicity and full memory barrier,
+    // making volatile unnecessary for this disposal guard pattern
     private int _isDisposed;
 
     public void FlushAndDisposeAll()
@@ -26,25 +28,23 @@ public void FlushAndDisposeAll()
             return;
         }
 
-        // ToArray() is thread-safe on ConcurrentBag
-        var snapshot = _loggers.ToArray();
-
-        foreach (var logger in snapshot.Where(x => x != null).OrderBy(x => x.LastLogWritten))
+        // Values provides a snapshot for safe enumeration
+        foreach (var logger in _loggers.Values.Where(x => x != null).OrderBy(x => x.LastLogWritten))
         {
             logger.Dispose();
         }
     }
 
     public IModuleLogger? GetLogger(Type type)
     {
-        // ToArray() creates a snapshot for safe enumeration
-        return _loggers.ToArray().FirstOrDefault(logger => logger.GetType() == type);
+        // O(1) lookup via ConcurrentDictionary
+        return _loggers.TryGetValue(type, out var logger) ? logger : null;
     }
 
     public void AddLogger(ModuleLogger logger)
     {
-        // ConcurrentBag.Add is lock-free and thread-safe
-        _loggers.Add(logger);
+        // Thread-safe add; each module type should only have one logger instance
+        _loggers.TryAdd(logger.GetType(), logger);
     }
 
     public void Dispose()