@@ -1,6 +1,7 @@
 ---
 '@object-ui/types': minor
 '@object-ui/components': minor
+'@object-ui/plugin-form': minor
 ---
 
 The section grouping contract (objectui#6236, maintainer ruling 2026-08-27): a
@@ -30,8 +31,16 @@ Ruled semantics, now pinned in `section-grouping-6236.test.tsx`:
 Both halves ride the mechanism the field-level predicate already uses (return `null`;
 react-hook-form keeps the value and skips the unmounted control), so field-level and
 section-level visibility cannot drift apart. The zod mirror (`FormFieldSchema`) declares
-the key with the same scope note. Scope note: the plugin-form `section-divider` synthesis
-sites do not yet stamp the claim onto the dividers they emit — an authored section
-predicate on those chains still gates only the heading until that wiring lands (the
-remaining half of objectui#6236). The tabbed arm's predicate slot (objectui#6237) is
+the key with the same scope note.
+
+`@object-ui/plugin-form` wires the producer half: all six `section-divider` synthesis
+sites (ObjectForm's stacked simple path, ModalForm's sectioned and derived-fieldGroup
+paths, DrawerForm's sectioned and derived-fieldGroup paths, SplitForm's panes) now stamp
+the membership claim onto the divider they emit, from the RESOLVED member list — so an
+authored `FormSection.visibleWhen` finally hides the whole section on the object-view
+chain, matching the console renderer. The #6111 honest pin (`measured scope`) flipped
+accordingly: it now pins heading-and-fields hiding together, and every per-layout DENIED
+row asserts the claimed member as well as the heading. The derived-fieldGroup sites carry
+the claim for uniformity but stay fail-open — the spec `fieldGroups` vocabulary has no
+section-predicate slot to author. The tabbed arm's predicate slot (objectui#6237) is
 designed to reuse this same grouping contract.
@@ -586,6 +586,9 @@ export const DrawerForm: React.FC<DrawerFormProps> = ({
       schema.sections.forEach((section, index) => {
         const sectionKey = section.name || String(index);
         const isCollapsed = collapsedSections[sectionKey] ?? (section.collapsed ?? false);
+        // Resolved before the divider push so the membership claim below can
+        // name exactly the fields this group contributes (#6236).
+        const sectionFields = buildSectionFields(section);
 
         allFields.push({
           name: `__section_${sectionKey}`,
@@ -594,6 +597,9 @@ export const DrawerForm: React.FC<DrawerFormProps> = ({
           // ADR-0089 section predicate (#6111) — the renderer evaluates it on
           // this pseudo-field with the host predicate scope bound (#6010).
           visibleWhen: (section as any).visibleWhen,
+          // The membership claim (#6236): resolved member names, so the
+          // predicate gates the whole group.
+          fields: sectionFields.map(f => f.name),
           colSpan: 4,
           collapsible: section.collapsible,
           collapsed: isCollapsed,
@@ -603,7 +609,6 @@ export const DrawerForm: React.FC<DrawerFormProps> = ({
           className: (section as any).className,
         } as any);
 
-        const sectionFields = buildSectionFields(section);
         if (isCollapsed) {
           allFields.push(...sectionFields.map(f => ({ ...f, hidden: true })));
         } else {
@@ -652,6 +657,9 @@ export const DrawerForm: React.FC<DrawerFormProps> = ({
             type: 'section-divider',
             // ADR-0089 section predicate (#6111).
             visibleWhen: (section as any).visibleWhen,
+            // The membership claim (#6236): resolved member names, so the
+            // predicate gates the whole group.
+            fields: body.map(f => f.name),
             colSpan: 4,
             collapsible: section.collapsible,
             collapsed: isCollapsed,
 
@@ -716,6 +716,10 @@ export const ModalForm: React.FC<ModalFormProps> = ({
             // ADR-0089 section predicate (#6111) — the renderer evaluates it on
             // this pseudo-field with the host predicate scope bound (#6010).
             visibleWhen: g.visibleWhen,
+            // The membership claim (#6236): resolved member names, so the
+            // predicate gates the whole group (same spelling as the
+            // `fieldTabs` claim above).
+            fields: g.fields.map((f) => f.name),
             colSpan: 4,
             className: g.className,
           } as any);
@@ -748,6 +752,9 @@ export const ModalForm: React.FC<ModalFormProps> = ({
             type: 'section-divider',
             // ADR-0089 section predicate (#6111).
             visibleWhen: (section as any).visibleWhen,
+            // The membership claim (#6236): resolved (post-FLS) member names,
+            // so the predicate gates the whole group.
+            fields: body.map((f) => f.name),
           } as any);
         }
         allFields.push(...(columns > 1 ? applyAutoColSpan(body, columns) : body));
 
@@ -1224,6 +1224,13 @@ const SimpleObjectForm: React.FC<ObjectFormComponentProps> = ({
           // bound (#6010), so copying it here is what makes the authored
           // section predicate reach an evaluator at all.
           visibleWhen: (section as any).visibleWhen,
+          // The membership claim (#6236): the RESOLVED member names — the same
+          // strings the renderer's flat list carries — so the section
+          // predicate gates the whole group, not just this heading. Resolved
+          // rather than authored on purpose: the authored `section.fields`
+          // entries can be spec field-defs, and a perms-filtered field is not
+          // in the form at all.
+          fields: sectionFields.map(f => f.name),
           colSpan: 4,
           collapsible: section.collapsible,
           collapsed: isCollapsed,
 
@@ -386,6 +386,9 @@ export const SplitForm: React.FC<SplitFormProps> = ({
           // ADR-0089 section predicate (#6111) — the renderer evaluates it on
           // this pseudo-field with the host predicate scope bound (#6010).
           visibleWhen: section.visibleWhen,
+          // The membership claim (#6236): resolved member names, so the
+          // predicate gates the whole group.
+          fields: body.map(f => f.name),
           colSpan: 4,
           className: section.className,
         } as any);
 
@@ -70,16 +70,26 @@
  * everywhere, which is precisely why the ALLOWED rows could never have caught
  * this.
  *
- * ## Scope, measured — what this does NOT claim
+ * ## Scope — the whole group, since objectui#6236
  *
- * The renderer treats `section-divider` as a presentational ROW and holds no
- * association between it and the fields that follow it, so a false predicate
- * removes the HEADING and leaves the section's fields rendering. The console
- * renderer (`apps/console/src/components/FormPage.tsx:1819`) drops the whole
- * `<section>`, fields included. That divergence is real and is filed
- * separately — it needs a renderer-side grouping contract, not another line in
- * a layout. The `stillRendersItsFields` case below pins the CURRENT behaviour
- * honestly rather than letting the file imply a guarantee it does not deliver.
+ * objectui#6236 (maintainer ruling 2026-08-27) closed the divergence this
+ * header used to record: the renderer now holds a real divider-to-field
+ * association — the divider's membership claim (`FormField.fields`, stamped by
+ * every synthesis site above from the RESOLVED member list) — and a false
+ * section predicate hides the heading AND the claimed fields, matching the
+ * console renderer. So every DENIED row below asserts both halves: the heading
+ * (the #6111 deliverable) and the gated member field (the #6236 wiring). The
+ * hidden members skip client-side validation and their values still submit;
+ * those semantics are pinned at the renderer in
+ * `packages/components/src/renderers/form/__tests__/section-grouping-6236.test.tsx`
+ * — this file pins that each LAYOUT's synthesis site actually stamps the claim
+ * (an unstamped site reverts to heading-only, invisible to every other suite).
+ *
+ * Two derived-fieldGroup synthesis sites (ModalForm / DrawerForm
+ * `derivedSections`) also stamp the claim for uniformity, but the spec
+ * `fieldGroups` vocabulary has no section-predicate slot, so no authoring path
+ * can turn their gate on today and no DENIED row can discriminate them; they
+ * stay fail-open until that vocabulary grows a predicate.
  */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
@@ -192,6 +202,12 @@ const renderModalFormDirect = async (scope: Record<string, unknown>) => {
 /** The gated section's heading — `null` when the layout hid it. */
 const gatedHeading = () => screen.queryByText('Compensation');
 
+/**
+ * The gated section's claimed MEMBER field (#6236) — `null` when the layout's
+ * synthesis site stamped the membership claim and the gate took the group.
+ */
+const gatedField = () => screen.queryByLabelText(/salary/i);
+
 /**
  * Every layout, by name, with the mount that reaches its own synthesis site.
  * Named individually because a fix applied to five of six sites still passes a
@@ -221,25 +237,33 @@ const LAYOUTS: { label: string; mount: (scope: Record<string, unknown>) => Promi
 ];
 
 describe('#6111 — an authored section `visibleWhen` reaches an evaluator in every layout', () => {
-  describe('DENIED — the predicate resolves FALSE, so the section heading is HIDDEN', () => {
-    // ⚠️ THE deliverable. Green here is the only observation that separates
-    // "the predicate arrived and was evaluated" from "it never arrived" —
-    // every other row in this file is green on unfixed code.
+  describe('DENIED — the predicate resolves FALSE, so the whole section is HIDDEN', () => {
+    // ⚠️ THE deliverable, in two halves. The heading half (#6111) separates
+    // "the predicate arrived and was evaluated" from "it never arrived"; the
+    // member half (#6236) separates "this layout's synthesis site stamped the
+    // membership claim" from "the divider arrived claim-less and the gate
+    // stayed heading-only" — an unstamped site fails ONLY here, in the SHOWN
+    // direction, because a claim-less divider is valid compat behaviour
+    // everywhere else.
     for (const layout of LAYOUTS) {
       it(layout.label, async () => {
         await layout.mount(DENIED);
         expect(gatedHeading()).toBeNull();
+        expect(gatedField()).toBeNull();
       });
     }
   });
 
   describe('ALLOWED — the SAME predicate text, a user it admits ⇒ still SHOWN', () => {
     // The control. Without it, "hidden" is satisfied by a layout that dropped
     // the heading for an unrelated reason — a worse defect, invisible above.
+    // The member assertion keeps the same honesty for the group half: a gate
+    // that hides claimed fields unconditionally would pass every DENIED row.
     for (const layout of LAYOUTS) {
       it(layout.label, async () => {
         await layout.mount(ALLOWED);
         expect(gatedHeading()).not.toBeNull();
+        expect(gatedField()).not.toBeNull();
       });
     }
   });
@@ -274,26 +298,27 @@ describe('#6111 — an authored section `visibleWhen` reaches an evaluator in ev
         );
         await waitFor(() => expect(screen.getByText('Always')).toBeTruthy());
         expect(gatedHeading()).not.toBeNull();
+        expect(gatedField()).not.toBeNull();
       });
     }
   });
 
-  it('measured scope: a hidden section still renders its FIELDS (objectui#6111 follow-up)', async () => {
-    // NOT an endorsement — an honest pin of what this chain does and does not
-    // deliver. The renderer-side grouping contract EXISTS since objectui#6236
-    // (maintainer ruling 2026-08-27): a `section-divider` that claims its
-    // members (`FormField.fields: string[]`) gates the whole group — heading
-    // and fields together, hidden members skip client-side validation, values
-    // still submit (pinned in `packages/components/.../section-grouping-6236.
-    // test.tsx`). What is still missing is THIS CHAIN's half: the layouts'
-    // divider synthesis sites (`ObjectForm.tsx` and siblings) copy
-    // `visibleWhen` onto the pseudo-field but do not yet stamp the membership
-    // claim, so an authored section predicate still hides only the heading
-    // here — the fields stay, exactly as below. The console renderer drops
-    // the whole `<section>`. This assertion turning red is the SIGNAL that
-    // the synthesis wiring (the remaining half of objectui#6236) landed.
+  it('measured scope: a hidden section hides its FIELDS too (objectui#6236 wiring landed)', async () => {
+    // FLIPPED — deliberately, and exactly once. From #6111 until the #6236
+    // wiring landed, this case pinned the honest limitation: the divider was a
+    // presentational row, so a false section predicate removed the heading and
+    // LEFT THE FIELDS RENDERING (`expect(getByLabelText(/salary/i)).toBeTruthy()`
+    // stood here). #6111 wrote it so that its red flip would be the SIGNAL the
+    // grouping contract landed rather than a broken test — and that is what
+    // happened: the synthesis sites now stamp the membership claim
+    // (`fields: [...names]`) onto the divider, the renderer gates the whole
+    // group, and this case now pins the NEW contract on the same chain, the
+    // same mount, the same predicate: heading gone AND claimed field gone,
+    // matching the console renderer at last. Values still submit and hidden
+    // members skip client-side validation — pinned at the renderer in
+    // section-grouping-6236.test.tsx.
     await renderObjectForm(DENIED, { formType: 'simple' });
     expect(gatedHeading()).toBeNull();
-    expect(screen.getByLabelText(/salary/i)).toBeTruthy();
+    expect(gatedField()).toBeNull();
   });
 });
@@ -1069,17 +1069,18 @@ export interface ObjectFormSection {
    * `visibleWhen` surface uses, so one authored predicate text means one thing
    * everywhere (#6010). A broken predicate fails OPEN (the header renders).
    *
-   * ⚠️ Scope: the renderer-side grouping contract exists since objectui#6236
-   * (maintainer ruling 2026-08-27) — a `section-divider` row that carries the
-   * membership claim (`FormField.fields`, the FormFieldTab shape) gates its
-   * WHOLE group: heading and claimed fields hide together, the hidden fields
-   * skip client-side validation, and their values still submit (the console
-   * precedent, 2026-08-22 after #5594). Measured limit: the plugin-form
-   * layouts' `section-divider` synthesis sites copy `visibleWhen` onto the
-   * divider (objectui#6111) but do not yet stamp this claim, so an authored
-   * section predicate still gates only the HEADING on those chains until that
-   * wiring lands (the remaining half of objectui#6236). The console renderer
-   * (`apps/console/src/components/FormPage.tsx`) drops the whole `<section>`.
+   * Scope: this gates the WHOLE section (objectui#6236, maintainer ruling
+   * 2026-08-27). The plugin-form layouts stamp the membership claim
+   * (`FormField.fields`, the FormFieldTab shape) onto the `section-divider`
+   * row they synthesize, and the renderer then hides heading and claimed
+   * fields together on a FALSE predicate — matching the console renderer
+   * (`apps/console/src/components/FormPage.tsx`), which drops the whole
+   * section element. Hidden fields skip client-side validation (a user is
+   * never blocked by an error pointing at a control they cannot see) and
+   * their values still submit — visibility decides what is DRAWN and nothing
+   * else (the console precedent, 2026-08-22 after #5594). Derived
+   * `fieldGroups` sections carry no predicate slot, so their groups are
+   * always drawn.
    */
   visibleWhen?: string | { dialect?: string; source: string };