@@ -9,7 +9,7 @@ import {
 import { expandViewContainer } from '@objectstack/spec/ui';
 import { ActiveOrganizationStorage, TokenStorage, useAuth } from '@object-ui/auth';
 import { isMetaItemAbsentError, MetadataNotFoundError, type ObjectStackAdapter } from '@object-ui/data-objectstack';
-import { markSwitchedOffActionsByObject, normalizeSchemaReferenceKeys } from '@object-ui/core';
+import { isActionSwitchedOff, markSwitchedOffActions, markSwitchedOffActionsByObject, normalizeSchemaReferenceKeys } from '@object-ui/core';
 import { errorCodeIs } from '@object-ui/types';
 import { resolveInlineMode } from '@object-ui/plugin-form';
 import { MetadataCtx, useMetadata, type MetadataContextValue, type MetadataCacheState, type MetadataTypeStatus } from '@object-ui/react';
@@ -360,6 +360,37 @@ export function extractItems(res: unknown): any[] {
   return [];
 }
 
+/**
+ * The ingestion every OBJECT list read runs — the whole list and a package
+ * scope's alike, so a scoped definition is shaped exactly like the same object
+ * in `objects`. In place.
+ *
+ * 1. a legacy `reference_to` / `referenceTo` is folded onto `reference`;
+ * 2. [objectstack#27504] the envelope's `disabledActions`, keyed by object:
+ *    each object's switched-off action entries are stamped (symbol key), so
+ *    the action gates stop offering them.
+ */
+function ingestObjectList(items: any[], res: unknown): void {
+  for (const it of items) normalizeSchemaReferenceKeys(it);
+  if (res && typeof res === 'object' && !Array.isArray(res)) {
+    markSwitchedOffActionsByObject(items, (res as { disabledActions?: unknown }).disabledActions);
+  }
+}
+
+/**
+ * A private copy of an adapter-served object schema. `structuredClone` drops
+ * symbol-keyed properties, so the switched-off stamps the adapter put on the
+ * action entries (objectstack#27504) are carried onto the copy by name.
+ */
+function cloneServedObject(schema: unknown): unknown {
+  const copy = structuredClone(schema);
+  const actions = (schema as { actions?: unknown }).actions;
+  if (Array.isArray(actions)) {
+    markSwitchedOffActions(copy, actions.filter(isActionSwitchedOff).map((a: { name?: unknown }) => a.name));
+  }
+  return copy;
+}
+
 function extractItem(res: unknown): any | null {
   if (res == null) return null;
   if (typeof res === 'object' && 'item' in res) {
@@ -783,7 +814,7 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS }:
   const readObjectThroughAdapter = useCallback((name: string): Promise<unknown> => {
     adapterObjectNamesRef.current.add(name);
     return adapterRef.current.getObjectSchema(name).then(
-      (schema: unknown) => ({ item: schema == null ? schema : structuredClone(schema) }),
+      (schema: unknown) => ({ item: schema == null ? schema : cloneServedObject(schema) }),
       (err: unknown) => {
         throw err instanceof MetadataNotFoundError ? (err.details?.originalError ?? err) : err;
       },
@@ -896,16 +927,9 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS }:
           // object field defs at ingestion (the store-side choke point,
           // mirroring the adapter's getObjectSchema pass), so
           // `useMetadata().objects` consumers read `reference` alone
-          // (objectui#11070 round 4). Idempotent, in place.
-          if (type === 'object') {
-            for (const it of items) normalizeSchemaReferenceKeys(it);
-            // [objectstack#27504] The list envelope's `disabledActions`, keyed
-            // by object: each object's switched-off action entries are stamped
-            // (symbol key) so the action gates stop offering them.
-            if (res && typeof res === 'object' && !Array.isArray(res)) {
-              markSwitchedOffActionsByObject(items, (res as { disabledActions?: unknown }).disabledActions);
-            }
-          }
+          // (objectui#11070 round 4), and stamp the switched-off actions
+          // (objectstack#27504) — `ingestObjectList`. Idempotent, in place.
+          if (type === 'object') ingestObjectList(items, res);
           entry.items = items;
           entry.status = 'ready';
           entry.error = null;
@@ -1053,7 +1077,7 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS }:
         .then((res: unknown) => {
           if (scopesRef.current.get(packageId) !== entry) return;
           const items = extractItems(res);
-          for (const it of items) normalizeSchemaReferenceKeys(it);
+          ingestObjectList(items, res);
           const listed = new Set(items.map((it: any) => it?.name));
           // The by-name extras stay until their own answer replaces them.
           const extras = entry.items.filter((it: any) => !listed.has(it?.name) && entry.names.has(it?.name));
 
@@ -12,7 +12,7 @@
 
 import { describe, it, expect, vi } from 'vitest';
 import { render, waitFor } from '@testing-library/react';
-import { isActionSwitchedOff } from '@object-ui/core';
+import { isActionSwitchedOff, markSwitchedOffActions } from '@object-ui/core';
 import { MetadataProvider, useMetadata } from '../MetadataProvider';
 
 type Ctx = ReturnType<typeof useMetadata>;
@@ -22,11 +22,13 @@ const TASK = {
   actions: [{ name: 'showcase_mark_done' }, { name: 'showcase_log_time' }],
 };
 
-function makeAdapter(listBody: Record<string, unknown>) {
+function makeAdapter(listBody: Record<string, unknown>, served: Record<string, any> = {}) {
   return {
     clearCache: vi.fn(),
     invalidateCache: vi.fn(),
-    getObjectSchema: () => Promise.resolve(null),
+    // The adapter's by-name read, already stamped from its own envelope
+    // (`getObjectSchema.disabledActions-27504.test.ts` pins that half).
+    getObjectSchema: (name: string) => Promise.resolve(served[name] ?? null),
     getClient: () => ({
       meta: {
         getItems: (type: string) =>
@@ -37,6 +39,21 @@ function makeAdapter(listBody: Record<string, unknown>) {
   } as unknown as Parameters<typeof MetadataProvider>[0]['adapter'];
 }
 
+async function mount(listBody: Record<string, unknown>, served: Record<string, any> = {}): Promise<Ctx> {
+  let ctx: Ctx | null = null;
+  function Probe() {
+    ctx = useMetadata();
+    return null;
+  }
+  render(
+    <MetadataProvider adapter={makeAdapter(listBody, served)}>
+      <Probe />
+    </MetadataProvider>,
+  );
+  await waitFor(() => expect(ctx).not.toBeNull());
+  return ctx as unknown as Ctx;
+}
+
 async function objectsServed(listBody: Record<string, unknown>): Promise<any[]> {
   let ctx: Ctx | null = null;
   function Probe() {
@@ -69,4 +86,17 @@ describe('MetadataProvider stamps the list envelope disabledActions (objectstack
     const [task] = await objectsServed({ type: 'object', items: [TASK] });
     expect(task.actions.some(isActionSwitchedOff)).toBe(false);
   });
+
+  it('keeps the adapter\'s stamp on the by-name read, which hands out a private copy', async () => {
+    // `structuredClone` drops symbol keys: without carrying the stamp across,
+    // the record header (`useMetadataItem` → this read) kept a live button.
+    const ctx = await mount(
+      { type: 'object', items: [] },
+      { showcase_task: markSwitchedOffActions(structuredClone(TASK), ['showcase_mark_done']) },
+    );
+    const item = await ctx.getItem('object', 'showcase_task');
+    const byName = (n: string) => item.actions.find((a: any) => a.name === n);
+    expect(isActionSwitchedOff(byName('showcase_mark_done'))).toBe(true);
+    expect(isActionSwitchedOff(byName('showcase_log_time'))).toBe(false);
+  });
 });