@@ -458,7 +458,8 @@ jobs:
           # Path-sensitive flow analysis of local IDisposables — bugs the flat D1
           # detector cannot catch (use-after-dispose, double-dispose, leak-on-path).
           dotnet run --project frontend/roslyn/OwnSharp.Extractor -- \
-            frontend/roslyn/samples/FlowLocalsSample.cs --flow-locals -o "$RUNNER_TEMP/flow.json"
+            frontend/roslyn/samples/FlowLocalsSample.cs \
+            frontend/roslyn/samples/MemoryOwnerEscapeSample.cs --flow-locals -o "$RUNNER_TEMP/flow.json"
           out=$(python -m ownlang ownir "$RUNNER_TEMP/flow.json" || true)
           echo "$out"
           echo "$out" | grep -q "OWN002" || { echo "FAIL: expected OWN002 (use-after-dispose)"; exit 1; }
@@ -564,7 +565,13 @@ jobs:
           # `ctorMoved`: a pooled buffer handed to a constructor whose result is RETURNED transfers
           # ownership to the returned wrapper -> escaped -> silent (mined FP on
           # Pipelines.Sockets.Unofficial: ArrayPoolBufferWriter.CreateNewSegment).
-          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; do
+          # P-016 escape-via-projection (mined: ImageSharp Image.WrapMemory; CodeQL agrees it is
+          # no leak): an IMemoryOwner whose `.Memory` view is handed to a consumer as an argument
+          # escapes the owner -> silent ('handedOwner', in the list below); one whose `.Memory` is
+          # 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; }
+          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
           echo "OK: flow-sensitive OWN001/002/003 on real C# (path-sensitive, loops via while/foreach/for, try/finally sequential, never-vs-every-path wording, dispose-optional exempt, beyond flat)"
 
@@ -2578,6 +2578,19 @@ or ImplicitObjectCreationExpressionSyntax } init
                     // returns `new ArrayPoolRefCountedSegment(pool, array, prev)`).
                     else if ((idn.Parent is AssignmentExpressionSyntax asg && asg.Right == idn)
                         || (idn.Parent is ArgumentSyntax && !poolBuffers.Contains(nm) && !consumedArg)
+                        // An IMemoryOwner's `.Memory` view handed off as an ARGUMENT escapes the
+                        // OWNER: the Memory keeps the owner alive (it IS the backing), so a consumer
+                        // 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)
+                            && idn.Parent is MemberAccessExpressionSyntax { Name.Identifier.Text: "Memory" } projMem
+                            && projMem.Expression == idn
+                            && projMem.Parent is ArgumentSyntax
+                            && IsMemoryOwnerType(model.GetTypeInfo(idn).Type))
                         || (poolBuffers.Contains(nm) && PassedToEscapingCtor(idn, model)))
                         escapedLocals.Add(nm);
                 }
 
@@ -0,0 +1,39 @@
+using System;
+using System.Buffers;
+
+namespace Own.Samples;
+
+// P-016 escape-via-projection (mined: ImageSharp Image.WrapMemory; CodeQL agrees — no leak).
+//
+// An IMemoryOwner's `.Memory` view passed as an ARGUMENT hands the OWNER off: the Memory keeps
+// the owner alive (it IS the backing), so a consumer that stores it takes over the lifetime —
+// the owner is not leaked at method scope. Contrast: an owner whose `.Memory` is only READ
+// locally and never disposed IS a leak. Exercised with --flow-locals.
+
+internal sealed class PixelOwner : IMemoryOwner<byte>
+{
+    private readonly byte[] data = new byte[16];
+
+    public Memory<byte> Memory => this.data;
+
+    public void Dispose() { }
+}
+
+internal static class MemoryOwnerEscape
+{
+    private static void Store(Memory<byte> m) { }
+
+    // owner.Memory handed to a consumer (ambiguous transfer) -> owner escapes -> SILENT.
+    public static void Transferred()
+    {
+        var handedOwner = new PixelOwner();
+        Store(handedOwner.Memory);            // .Memory passed as an arg -> ownership handed off
+    }
+
+    // owner.Memory only READ locally (a length); owner never disposed -> real leak -> must WARN.
+    public static int ReadOnlyLeak()
+    {
+        var leakedOwner = new PixelOwner();
+        return leakedOwner.Memory.Length;     // a local read, NOT a handoff
+    }
+}