@@ -18,7 +18,7 @@ An **extension policy** describes what that extension is allowed to introduce or
 An effect is **covered** when an analyzed method graph or a conservative summary represents all of its relevant runtime behavior.
 An **entry summary**, for example, represents the possible arguments of calls whose call sites are unavailable to the analysis.
 
-A method can be known to the builder while analysis of its body is deferred to a later image layer.
+A method can be known to the builder while its body remains outside the current analysis, for example when deferred to a later image layer.
 Conversely, at run time an analyzed method can receive and use a concrete value supplied by an extension.
 The component that declares a class therefore does not, by itself, determine which effects the analysis covers.
 
@@ -148,6 +148,40 @@ Enumerating known instantiated types is insufficient when a field can hold value
 Such a field requires an open value approximation independently of the number of known types.
 A closed value bound permits a finite approximation only under the conditions in [Representing Possible Runtime Types](#representing-possible-runtime-types).
 
+### Effects of Unanalyzed Method Bodies
+
+Whether a method's entry is **open** (callers outside the current analysis may invoke it) or **closed** (all permitted calls are represented by analyzed call sites) is separate from whether its body is analyzed.
+An open entry requires a summary of arguments from callers whose call sites are unavailable to the analysis; when the body is analyzed, its stores propagate those values into fields.
+If a permitted method body is outside the current analysis, its effects require conservative summaries even when its declaring component is closed.
+
+Suppose `ClassX` has a closed type hierarchy, but the extension policy permits the implementation of `ClassX.foo` to remain outside the current analysis.
+Knowing all subtypes of `ClassX` does not account for writes performed by that implementation.
+The extension policy must specify whether `ClassX.foo` may write `ClassX.f`.
+If writes are permitted, compiled readers of the field must account for them through analyzed stores or a conservative mutation summary.
+The extension mechanism must reject writes that are forbidden or whose effects are not covered.
+Summarizing the call's return values and continuation does not establish mutation coverage.
+
+A field summary must represent unknown extension types when the effective field bound is open.
+If the value can be an array, the summary must cover its element values as well as its reference, including values reached through nested arrays.
+These requirements apply independently of how the extension is supplied.
+For example, a method deferred to a later image layer supplies no analyzed stores when the shared layer is compiled.
+Readers retained from that layer must already account for its permitted writes; analyzing the writer later cannot repair their assumptions.
+
+### Conservative Validation of Layered Closed-Field Writes
+
+Layered builds reject uncovered direct writes to fields deliberately excluded from shared-layer mutation summaries.
+The check uses stores observed after parsing and the parsing-support hook, before static-final-field folding, pre-analysis escape analysis, and final canonicalization.
+This is a conservative validation boundary: a recorded write can cause rejection even if a later optimization removes its store or enclosing branch.
+Parsing-time simplifications have already occurred, so the recorded writes are not a complete bytecode-level summary.
+
+An immutable metadata record accompanies each persisted analysis graph and retains these validation obligations even when the optimized graph no longer contains the stores.
+Freshly parsed extension methods and reused graphs validate writes from this same collection boundary, before caller-specific specialization.
+The metadata does not mark fields as written in analysis or add mutation summaries.
+
+Allowing eliminated writes requires distinguishing eliminations justified by facts that remain valid across layers from those relying on closed-world assumptions protected by this check.
+The absence of a store in an optimized graph alone does not establish that distinction.
+Until such a boundary is established, validation conservatively retains all writes observed at the current collection point.
+
 ## Architectural Requirements
 
 These requirements describe the intended contract for every supported configuration.
 
@@ -56,7 +56,11 @@ public interface ExtensionPolicy {
     /**
      * Returns whether the field is closed to direct writes from the open world. Closed fields still
      * receive values through analyzed stores, including values originating in the open world.
-     * Unsafe access must be accounted for by the corresponding analysis handling.
+     * Unsafe access must be accounted for by the corresponding analysis handling. A method whose
+     * body is not analyzed at the current boundary may still write fields declared by a closed
+     * component. Every permitted write must be covered by analyzed code or a conservative mutation
+     * summary. The extension mechanism must reject writes for which that coverage cannot be
+     * established.
      */
     boolean isFieldClosed(ResolvedJavaField field);
 
@@ -65,7 +69,8 @@ public interface ExtensionPolicy {
      * open-world entry seeding.
      * <p>
      * This does not close the method's parameter or return types, or the targets of calls made by
-     * its body.
+     * its body. Entry classification does not establish whether the body is analyzed or its effects
+     * are covered by summaries.
      */
     boolean isMethodEntryClosed(AnalysisMethod method);
 
@@ -74,8 +79,9 @@ public interface ExtensionPolicy {
      * kind. This handling covers possible returned values and predicates indicating that the call
      * may return normally, including void calls.
      * <p>
-     * This decision applies independently of the containing method's entry classification. Delayed
-     * callees require additional handling when they are linked.
+     * This decision applies independently of the containing method's entry classification. Callees
+     * whose bodies are not analyzed require additional result and continuation coverage when they
+     * are linked.
      */
     boolean requiresOpenInvokeResult(AnalysisType receiverType, boolean directInvoke);
 }
@@ -41,6 +41,7 @@
 
 import com.oracle.graal.pointsto.BigBang;
 import com.oracle.graal.pointsto.PointsToAnalysis;
+import com.oracle.graal.pointsto.flow.AnalysisParsedGraph.GraphMetadata;
 import com.oracle.graal.pointsto.flow.AnalysisParsedGraph.Stage;
 import com.oracle.graal.pointsto.flow.InvokeTypeFlow;
 import com.oracle.graal.pointsto.meta.AnalysisField;
@@ -244,7 +245,7 @@ public void addMethodAfterParsingListener(BiConsumer<AnalysisMethod, StructuredG
      * {@link com.oracle.graal.pointsto.flow.AnalysisParsedGraph.Stage#isRequiredStage(Stage, AnalysisMethod)}
      * is true for the given method and stage {@link Stage#BYTECODE_PARSED}. If the hook is invoked,
      * it is guaranteed to be invoked before
-     * {@link #methodAfterParsingHook(BigBang, AnalysisMethod, StructuredGraph)} .
+     * {@link #methodAfterParsingHook}.
      *
      * @param bb the analysis engine
      * @param method the newly parsed method
@@ -258,14 +259,15 @@ public void methodAfterBytecodeParsedHook(BigBang bb, AnalysisMethod method, Str
     }
 
     /**
-     * Can be overwritten to run code after a method is parsed and all pre-analysis optimizations
-     * are finished. This hook will be invoked before the graph is made available to the analysis.
+     * Processes a freshly parsed method graph before encoding and publication to the analysis.
+     * Implementations may apply pre-analysis optimizations and collect metadata for this parse.
      *
      * @param bb the analysis engine
      * @param method the newly parsed method
      * @param graph the method graph
+     * @param metadata collects metadata to retain with this graph's encoding
      */
-    public void methodAfterParsingHook(BigBang bb, AnalysisMethod method, StructuredGraph graph) {
+    public void methodAfterParsingHook(BigBang bb, AnalysisMethod method, StructuredGraph graph, GraphMetadata.Builder metadata) {
         for (BiConsumer<AnalysisMethod, StructuredGraph> listener : methodAfterParsingListeners) {
             listener.accept(method, graph);
         }
 
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -24,9 +24,12 @@
  */
 package com.oracle.graal.pointsto.flow;
 
+import java.util.List;
+
 import com.oracle.graal.pointsto.BigBang;
 import com.oracle.graal.pointsto.api.HostVM;
 import com.oracle.graal.pointsto.infrastructure.GraphProvider.Purpose;
+import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.graal.pointsto.phases.SubstrateIntrinsicGraphBuilder;
 import com.oracle.graal.pointsto.util.AnalysisError;
@@ -128,20 +131,57 @@ public static boolean isRequiredStage(Stage stage, AnalysisMethod method) {
         HOST_ARCHITECTURE = compiler.getGraalRuntime().getCapability(RuntimeProvider.class).getHostBackend().getTarget().arch;
     }
 
-    private static final AnalysisParsedGraph EMPTY = new AnalysisParsedGraph(null, false);
+    /**
+     * Immutable metadata captured for one parsed graph, retained with its encoding so subsequent
+     * parsing of the same method cannot replace it. Closed-field writes describe stores observed
+     * at the collection boundary, including stores eliminated before encoding. They conservatively
+     * retain validation obligations rather than describing only the encoded graph's remaining effects.
+     *
+     * @param closedFieldWrites always-closed fields written before optimizations can remove their
+     *            stores; this is validation metadata for later layers and does not mark fields as
+     *            written in the analysis
+     */
+    public record GraphMetadata(List<AnalysisField> closedFieldWrites) {
+        private static final GraphMetadata EMPTY = new GraphMetadata(List.of());
+
+        public GraphMetadata {
+            closedFieldWrites = List.copyOf(closedFieldWrites);
+        }
+
+        /** Collects metadata during one parsing operation, before publishing the encoded graph. */
+        public static final class Builder {
+            private List<AnalysisField> closedFieldWrites = List.of();
+
+            public void setClosedFieldWrites(List<AnalysisField> closedFieldWrites) {
+                this.closedFieldWrites = List.copyOf(closedFieldWrites);
+            }
+
+            public GraphMetadata build() {
+                return closedFieldWrites.isEmpty() ? EMPTY : new GraphMetadata(closedFieldWrites);
+            }
+        }
+    }
+
+    private static final AnalysisParsedGraph EMPTY = new AnalysisParsedGraph(null, false, GraphMetadata.EMPTY);
 
     private final EncodedGraph encodedGraph;
     private final boolean isIntrinsic;
+    private final GraphMetadata metadata;
 
-    public AnalysisParsedGraph(EncodedGraph encodedGraph, boolean isIntrinsic) {
+    public AnalysisParsedGraph(EncodedGraph encodedGraph, boolean isIntrinsic, GraphMetadata metadata) {
         this.isIntrinsic = isIntrinsic;
         this.encodedGraph = encodedGraph;
+        this.metadata = metadata;
     }
 
     public EncodedGraph getEncodedGraph() {
         return encodedGraph;
     }
 
+    public GraphMetadata getMetadata() {
+        return metadata;
+    }
+
     public boolean isIntrinsic() {
         return isIntrinsic;
     }
@@ -251,6 +291,7 @@ public static AnalysisParsedGraph createFinalStage(BigBang bb, AnalysisMethod me
         return optimizeAndEncode(bb, method, decodeParsedGraph(bb, method, stage1Graph), stage1Graph.isIntrinsic, Stage.OPTIMIZATIONS_APPLIED);
     }
 
+    /** Decode a non-empty parsed graph without inlining or applying optimizations. */
     @SuppressWarnings("try")
     private static StructuredGraph decodeParsedGraph(BigBang bb, AnalysisMethod method, AnalysisParsedGraph analysisParsedGraph) {
         // Persisted analysis graphs do not consume the structured optimization log, so avoid
@@ -281,13 +322,14 @@ private static AnalysisParsedGraph optimizeAndEncode(BigBang bb, AnalysisMethod
              * Must be called before any other thread can access the graph, i.e., before the graph
              * is published.
              */
+            GraphMetadata.Builder metadata = new GraphMetadata.Builder();
             switch (stage) {
                 case BYTECODE_PARSED -> bb.getHostVM().methodAfterBytecodeParsedHook(bb, method, graph);
-                case OPTIMIZATIONS_APPLIED -> bb.getHostVM().methodAfterParsingHook(bb, method, graph);
+                case OPTIMIZATIONS_APPLIED -> bb.getHostVM().methodAfterParsingHook(bb, method, graph, metadata);
             }
 
             EncodedGraph encodedGraph = GraphEncoder.encodeSingleGraph(graph, HOST_ARCHITECTURE);
-            return new AnalysisParsedGraph(encodedGraph, isIntrinsic);
+            return new AnalysisParsedGraph(encodedGraph, isIntrinsic, metadata.build());
         } catch (Throwable e) {
             throw graph.getDebug().handle(e);
         }
 
@@ -107,6 +107,8 @@ struct PersistedAnalysisMethod {
   strengthenedGraphLocation @26 :Text;
   hostedMethodIndex @27 :HostedMethodIndex;
   compilationBehaviorOrdinal @28 :Int8;
+  # IDs of always-closed fields written by the unspecialized graph, captured before caller-specific inlining and graph optimizations.
+  closedFieldWrites @43 :List(FieldId);
   wrappedMethod :union {
     none @29 :Void; # default
     factoryMethod :group {
 
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -32,12 +32,15 @@
 import org.graalvm.collections.EconomicSet;
 
 import com.oracle.graal.pointsto.api.HostVM;
+import com.oracle.graal.pointsto.meta.AnalysisField;
+import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.graal.pointsto.meta.AnalysisType;
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
 import com.oracle.svm.core.c.BoxedRelocatedPointer;
 import com.oracle.svm.core.code.ImageCodeInfo;
 import com.oracle.svm.core.feature.InternalFeature;
 import com.oracle.svm.core.imagelayer.ImageLayerBuildingSupport;
+import com.oracle.svm.core.util.UserError;
 import com.oracle.svm.hosted.FeatureImpl.BeforeAnalysisAccessImpl;
 import com.oracle.svm.hosted.FeatureImpl.BeforeCompilationAccessImpl;
 import com.oracle.svm.hosted.imagelayer.HostedImageLayerBuildingSupport;
@@ -93,6 +96,27 @@ public void beforeAnalysis(BeforeAnalysisAccess a) {
         access.registerAsInHeap(ReflectionUtil.lookupClass(false, "java.util.concurrent.ConcurrentHashMap$CounterCell"));
     }
 
+    /** Validate writes to always-closed fields recorded from a newly parsed or persisted method graph. */
+    static void checkNewClosedFieldWrites(AnalysisMethod method, Iterable<AnalysisField> closedFieldWrites) {
+        if (!method.analyzedInPriorLayer()) {
+            for (AnalysisField field : closedFieldWrites) {
+                /*
+                 * These fields are deliberately excluded from shared-layer mutation summaries to
+                 * retain closed-world optimizations. Reject new writes because their compatibility
+                 * with assumptions used to compile the shared layer is not established. A future
+                 * mechanism could record those assumptions and allow otherwise permitted writes
+                 * after verifying that they preserve all affected assumptions; compatibility with
+                 * the field's type bound alone is insufficient.
+                 */
+                if (field.isInSharedLayer()) {
+                    throw UserError.abort("Method %s writes field %s, which must remain closed across image layers. " +
+                                    "Analyze the write in the initial layer instead of delaying it to an extension layer.",
+                                    method.format("%H.%n(%p)"), field.format("%H.%n"));
+                }
+            }
+        }
+    }
+
     @Override
     public void beforeCompilation(BeforeCompilationAccess a) {
         BeforeCompilationAccessImpl access = (BeforeCompilationAccessImpl) a;