fix(extractor): scope projection-escape to new'd owners only — keep pool-rental tracking (Codex/CodeRabbit P1)

The first cut excluded only poolBuffers (ArrayPool) and usingMemoryOwners (using-declared
MemoryPool), but a `var` MemoryPool.Rent owner is in neither — so its `.Memory` handoff wrongly
untracked it, dropping the dangling-borrow / double-dispose findings (OWN002/OWN003). The
corpus benchmark caught it: memorypool-double-dispose regressed (recall 23 -> 22).

Scope the projection-escape to a new `newedDisposables` whitelist — locals created via `new`
(the WrapMemory `new ByteMemoryManager(...)` shape). A pool rental of ANY kind (ArrayPool or
MemoryPool, `var` or `using`) is never `new`'d, so it keeps its full use-after-dispose tracking;
the renter owns the Return/Dispose. Stricter and more self-evident than enumerating pool sets.

Sample/CI gain a MemoryPool-owner boundary case: `pooled.Dispose(); Store(pooled.Memory)` must
still trip OWN002 (not be silenced). handedOwner stays silent, leakedOwner still warns.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Rg8kSk1YT14x7A1vo5zgED

Author: claude

.github/workflows/ci.yml

@@ -571,6 +571,11 @@ jobs:
           # only READ locally and never disposed still leaks ('leakedOwner').
           echo "$out" | grep -qE "OWN001.*'leakedOwner'" \
             || { echo "FAIL: expected OWN001 on the read-only, never-disposed IMemoryOwner"; exit 1; }
+          # boundary: the projection-escape is scoped to `new`'d owners — a MemoryPool RENTAL whose
+          # .Memory is handed off after Dispose must KEEP its use-after-dispose tracking, NOT be
+          # silenced (Codex/CodeRabbit P1; benchmark memorypool-double-dispose parity).
+          echo "$out" | grep -qE "OWN002.*'pooled'" \
+            || { echo "FAIL: a MemoryPool owner's .Memory used after Dispose must still trip OWN002"; exit 1; }
           for ok in clean looped esc exemptTask whileClean asyncDisposed asyncDisposedCfg tfClean tfCatch tfRet tfNull cda daci cif ctorLater lamPrior other doClean swAll ncf captured shaClean stopped defer ctorMoved handedOwner; do
             if echo "$out" | grep -q "'$ok'"; then echo "FAIL: silent/exempt case '$ok' was reported"; exit 1; fi
           done

frontend/roslyn/OwnSharp.Extractor/Program.cs

@@ -2461,6 +2461,7 @@ or ImplicitObjectCreationExpressionSyntax
                 var candidates = new HashSet<string>();
                 var poolBuffers = new HashSet<string>();   // candidates that are ArrayPool<T> buffers
                 var usingMemoryOwners = new HashSet<string>();   // `using`-declared MemoryPool owners
+                var newedDisposables = new HashSet<string>();    // candidates created via `new` (NOT a pool rental / factory)
                 foreach (var ld in mbody.DescendantNodes().OfType<LocalDeclarationStatementSyntax>())
                 {
                     if (ld.UsingKeyword != default)
@@ -2481,7 +2482,10 @@ or ImplicitObjectCreationExpressionSyntax
                                                    or ImplicitObjectCreationExpressionSyntax } init
                             && model.GetTypeInfo(init.Value).Type is { } dt
                             && ImplementsIDisposable(dt) && !IsDisposeOptional(dt))
+                        {
                             candidates.Add(v.Identifier.Text);
+                            newedDisposables.Add(v.Identifier.Text);
+                        }
                         else if (IsPoolRent(v.Initializer?.Value, model))   // an ArrayPool<T> buffer
                         {
                             candidates.Add(v.Identifier.Text);
@@ -2583,10 +2587,12 @@ or ImplicitObjectCreationExpressionSyntax } init
                         // that stores it — `MemoryGroup.Wrap(owner.Memory)` -> the returned Image —
                         // takes over the lifetime; the owner is not leaked here. Scoped to
                         // IMemoryOwner.`Memory` (not any `local.Member`, so a FileStream whose
-                        // `.Length` is read still leaks) and to non-pool / non-`using` owners (a
-                        // MemoryPool / `using` owner keeps its dangling-borrow tracking). Mined FP on
-                        // ImageSharp Image.WrapMemory; CodeQL agrees it is no leak (interprocedural).
-                        || (!poolBuffers.Contains(nm) && !usingMemoryOwners.Contains(nm)
+                        // `.Length` is read still leaks) and to `new`'d owners ONLY: a pool rental —
+                        // ArrayPool or MemoryPool, `var` or `using` — keeps its dangling-borrow / use-
+                        // after-dispose (OWN002/OWN003) tracking through `.Memory` handoffs, since the
+                        // RENTER owns the Return/Dispose (Codex/CodeRabbit; benchmark memorypool-double-
+                        // dispose). Mined FP on ImageSharp Image.WrapMemory; CodeQL agrees — no leak.
+                        || (newedDisposables.Contains(nm)
                             && idn.Parent is MemberAccessExpressionSyntax { Name.Identifier.Text: "Memory" } projMem
                             && projMem.Expression == idn
                             && projMem.Parent is ArgumentSyntax

frontend/roslyn/samples/MemoryOwnerEscapeSample.cs

@@ -36,4 +36,14 @@ public static int ReadOnlyLeak()
         var leakedOwner = new PixelOwner();
         return leakedOwner.Memory.Length;     // a local read, NOT a handoff
     }
+
+    // A MemoryPool RENTAL (not a `new`'d owner) keeps its dangling-borrow tracking through a
+    // `.Memory` handoff: projection-escape is scoped to `new`'d owners only, so using `pooled.Memory`
+    // after Dispose still trips OWN002 — the rule must NOT silence it (Codex/CodeRabbit P1).
+    public static void PoolOwnerNotEscaped()
+    {
+        var pooled = MemoryPool<byte>.Shared.Rent(16);
+        pooled.Dispose();
+        Store(pooled.Memory);                 // use of .Memory AFTER Dispose -> OWN002, must NOT be silenced
+    }
 }