@@ -211,9 +211,18 @@ jobs:
             echo "FAIL: a resolved non-IDisposable Writer/Reader field was wrongly flagged"; exit 1
           fi
           # control: resolved IDisposable fields (MemoryStream / CancellationTokenSource) the
-          # class new's but never disposes must STILL warn — real detection intact.
+          # class new's but never disposes must STILL warn — real detection intact. (CodeRabbit:
+          # tie the assertion to OWN001 + the disposable-field resource, not just the class name.
+          # Severity-agnostic on purpose — the disposable-field leak renders as error, not warning.)
+          echo "$out" | grep -qE "ResolvedDisposableSample\.cs:[0-9]+:.*\[OWN001\].*resource: disposable field" \
+            || { echo "FAIL: expected the OWN001 disposable-field finding on the resolved IDisposable control"; exit 1; }
           echo "$out" | grep -q "HolderWithRealDisposable" \
-            || { echo "FAIL: a resolved IDisposable field (MemoryStream/CTS) must still warn"; exit 1; }
+            || { echo "FAIL: the resolved IDisposable control (MemoryStream/CTS) must be flagged by owner name"; exit 1; }
+          # dispose-optional control (Codex): Task / DataTable ARE IDisposable but disposal is
+          # optional (IsDisposeOptional) — a new'd, undisposed field of these must stay SILENT.
+          if echo "$out" | grep -q "HolderWithDisposeOptional"; then
+            echo "FAIL: a dispose-optional (Task/DataTable) field was wrongly flagged"; exit 1
+          fi
           # 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" \
 
@@ -1537,24 +1537,14 @@ static bool IsOwnedDisposableType(TypeSyntax type, SemanticModel model)
     var sym = model.GetTypeInfo(type).Type;
     if (sym is null or IErrorTypeSymbol)
         return IsDisposableType(type.ToString());
-    return ImplementsDisposable(sym);
+    // Resolved: demand a REAL IDisposable, but keep the optional-dispose exemption
+    // (Task/ValueTask/DataTable/DataSet/DataView) that the flat name path got for free —
+    // their Dispose is a no-op / they hold only a lazy wait handle, so an undisposed field
+    // of these is not a leak and must stay silent (Codex). Both helpers already exist and
+    // are shared with the flow detector.
+    return ImplementsIDisposable(sym) && !IsDisposeOptional(sym);
 }
 
-static bool ImplementsDisposable(ITypeSymbol sym)
-{
-    if (IsDisposableInterface(sym))
-        return true;
-    foreach (var i in sym.AllInterfaces)
-        if (IsDisposableInterface(i))
-            return true;
-    return false;
-}
-
-static bool IsDisposableInterface(ITypeSymbol t) =>
-    t.SpecialType == SpecialType.System_IDisposable
-    || (t.Name == "IAsyncDisposable"
-        && t.ContainingNamespace is { Name: "System", ContainingNamespace.IsGlobalNamespace: true });
-
 // --- P-006: DI registration + constructor graph (DI001 captive dependency) ---
 // A syntactic pass over the same trees, independent of the event/disposable
 // detectors: collect each class's constructor parameter types (the dependency
 
@@ -1,5 +1,7 @@
+using System.Data;
 using System.IO;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace Own.Samples;
 
@@ -39,3 +41,14 @@ public sealed class HolderWithRealDisposable
 
     public long Use() => this.stream.Length + this.cts.Token.GetHashCode();
 }
+
+// Dispose-optional control (Codex): Task and DataTable ARE IDisposable, but disposal is
+// conventionally optional (IsDisposeOptional) — a `new`'d, undisposed field of these must
+// stay SILENT even though it resolves as IDisposable.
+public sealed class HolderWithDisposeOptional
+{
+    private readonly Task task = new(() => { });   // Task: IDisposable but dispose-optional
+    private readonly DataTable table = new();       // DataTable: IDisposable but dispose-optional
+
+    public int Use() => this.task.Id + this.table.Columns.Count;
+}