@@ -145,6 +145,7 @@ jobs:
             frontend/roslyn/samples/EventSourceCountersSample.cs \
             frontend/roslyn/samples/AppDomainShutdownSample.cs \
             frontend/roslyn/samples/AliasDisposeSample.cs \
+            frontend/roslyn/samples/SemaphoreFieldSample.cs \
             -o "$RUNNER_TEMP/facts.json"
           cat "$RUNNER_TEMP/facts.json"
       - name: Check facts through the core
@@ -261,6 +262,21 @@ jobs:
           # same-named local disposed in another method must NOT credit the field, so it still leaks.
           echo "$out" | grep -qE "AliasDisposeSample\.cs:[0-9]+:.*\[OWN001\].*'_scopedLeak'" \
             || { echo "FAIL: a same-named local in another scope must not be miscredited (symbol-scoped aliases)"; exit 1; }
+          # P-004 SemaphoreSlim FIELD dispose-optional (mined: Npgsql NpgsqlDataSource._setupMappingsSemaphore):
+          # a SemaphoreSlim field used only for Wait/Release (AvailableWaitHandle never read) frees nothing on
+          # Dispose -> must be SILENT.
+          if echo "$out" | grep -q "'_optionalSem'"; then
+            echo "FAIL: a SemaphoreSlim field whose AvailableWaitHandle is never read was wrongly reported (dispose-optional)"; exit 1
+          fi
+          # gate control: a SemaphoreSlim field whose AvailableWaitHandle IS read allocates a handle Dispose
+          # must release -> it must STILL warn (proves the exemption is gated, not blanket — Codex).
+          echo "$out" | grep -qE "SemaphoreFieldSample\.cs:[0-9]+:.*\[OWN001\].*'_handleSem'" \
+            || { echo "FAIL: a SemaphoreSlim field whose AvailableWaitHandle is read must still warn"; exit 1; }
+          # type-scope control: a non-SemaphoreSlim owned IDisposable (CTS) never disposed must STILL warn.
+          echo "$out" | grep -qE "SemaphoreFieldSample\.cs:[0-9]+:.*\[OWN001\].*'_ctsControl'" \
+            || { echo "FAIL: a non-SemaphoreSlim owned IDisposable field must still warn (exemption stays SemaphoreSlim-scoped)"; exit 1; }
+          # field-scoped: the existing method-bounded LOCAL SemaphoreSlim leak (FlowLocalsSample.semLeak) must
+          # be UNAFFECTED — checked in the --flow-locals step below; this exemption never touches IsDisposeOptional.
           # WPF004: an ignored `X.Subscribe(...)` result leaks; the captured+
           # disposed one stays silent. "ignored" is unique to the WPF004 message.
           echo "$out" | grep -q "MessengerViewModel.cs" \
 
@@ -2296,6 +2296,19 @@ or ImplicitObjectCreationExpressionSyntax
                     && ThisFieldName(a.Left) is { } cfn)   // THIS instance's field only — `other._c` must not exempt our field (CodeRabbit)
                     eventSourceCounters.Add(cfn);
 
+        // P-004 SemaphoreSlim field exemption (mined: Npgsql NpgsqlDataSource._setupMappingsSemaphore).
+        // SemaphoreSlim.Dispose() only frees a LAZILY-allocated wait handle — allocated solely when
+        // `.AvailableWaitHandle` is read — so a SemaphoreSlim field used purely for Wait/WaitAsync/Release
+        // leaks nothing and is dispose-optional. GATE: if `.AvailableWaitHandle` IS read on the field,
+        // that handle exists and Dispose must release it, so the field STAYS tracked (Codex). Collect the
+        // field names whose AvailableWaitHandle is read (this/bare receiver) so the loop below keeps them.
+        // Scoped to FIELDS only — the shared IsDisposeOptional (and the flow-locals detector / the
+        // deliberate method-bounded `semLeak` control) is intentionally left untouched (CodeRabbit).
+        var waitHandleSemaphores = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var ma in cls.DescendantNodes().OfType<MemberAccessExpressionSyntax>())
+            if (ma.Name.Identifier.Text == "AvailableWaitHandle" && ThisFieldName(ma.Expression) is { } whf)
+                waitHandleSemaphores.Add(whf);
+
         foreach (var fd in cls.Members.OfType<FieldDeclarationSyntax>())
         {
             // a `static` IDisposable field is a process-lifetime singleton (a shared
@@ -2323,6 +2336,13 @@ or ImplicitObjectCreationExpressionSyntax
                 if (eventSourceCounters.Contains(v.Identifier.Text)
                     && DerivesFromDiagnosticCounter(model.GetTypeInfo(fd.Declaration.Type).Type))
                     continue;
+                // a SemaphoreSlim field whose `.AvailableWaitHandle` is never read leaks nothing —
+                // Dispose() only frees that lazy handle — so it is dispose-optional and silent; if the
+                // handle IS read (in waitHandleSemaphores) it stays tracked. FIELD-scoped (Npgsql).
+                if (!waitHandleSemaphores.Contains(v.Identifier.Text)
+                    && model.GetTypeInfo(fd.Declaration.Type).Type is { Name: "SemaphoreSlim" } st
+                    && st.ContainingNamespace?.ToString() == "System.Threading")
+                    continue;
                 subs.Add(new
                 {
                     @event = v.Identifier.Text,
 
@@ -0,0 +1,46 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Own.Samples;
+
+// P-004 SemaphoreSlim FIELD dispose-optional (mined: Npgsql NpgsqlDataSource._setupMappingsSemaphore).
+// SemaphoreSlim.Dispose() only frees a lazily-allocated wait handle (allocated solely when
+// AvailableWaitHandle is read), so a SemaphoreSlim field used purely for Wait/WaitAsync/Release leaks
+// nothing and is dispose-optional. GATED on AvailableWaitHandle: if the field's AvailableWaitHandle is
+// read, the handle exists and Dispose must release it -> the field STAYS tracked (Codex). Scoped to
+// FIELDS only — method-bounded LOCAL SemaphoreSlims remain tracked via FlowLocalsSample.semLeak.
+
+// a SemaphoreSlim field used only for WaitAsync/Release, never disposed -> SILENT (dispose-optional).
+public sealed class OptionalSemaphore
+{
+    private readonly SemaphoreSlim _optionalSem = new SemaphoreSlim(1, 1);
+
+    public async Task RunAsync()
+    {
+        await _optionalSem.WaitAsync();
+        try { /* critical section */ }
+        finally { _optionalSem.Release(); }
+    }
+}
+
+// control (the gate): the field's AvailableWaitHandle IS read, so the wait handle is allocated and
+// Dispose must release it -> the field must STILL warn OWN001.
+public sealed class WaitHandleSemaphore
+{
+    private readonly SemaphoreSlim _handleSem = new SemaphoreSlim(0, 1);
+
+    public void Block()
+    {
+        _handleSem.AvailableWaitHandle.WaitOne();   // reads AvailableWaitHandle -> stays tracked
+    }
+}
+
+// control (type scope): a non-SemaphoreSlim owned IDisposable (CancellationTokenSource) never disposed
+// must STILL warn — the exemption is SemaphoreSlim-specific, not a blanket "any field".
+public sealed class HoldsCtsField
+{
+    private readonly CancellationTokenSource _ctsControl = new CancellationTokenSource();
+
+    public void Cancel() => _ctsControl.Cancel();
+}