@@ -0,0 +1,14 @@
+---
+'@object-ui/app-shell': patch
+---
+
+fix(app-shell): the metadata editor page tells its scoped inspector why it is read-only, so a flow's node inspector explains its disabled controls there too
+
+Clause-②: no
+Metadata-protocol: none
+
+The metadata editor page (Setup's item page, and Studio's "All metadata" area at `/studio/PKG/metadata/flow/NAME`) folds every read-only cause into one flag, and it passed that flag to the scoped inspector with no reason. A flow's node inspector therefore showed disabled controls with nothing to say why, while the same inspector on Studio's Automations pillar explained them.
+
+The page now hands the scoped inspector the reason (`MetadataInspectorProps.readOnlyReason`) as the sentence its own notice gives for the cause in force, in the notices' order: the walled security catalog; a read-only package; a lock, with the reason the server serves for it; a declaration-only catalog; a caller without the `manage_metadata` capability; an item a code package ships; and a type that is read-only at runtime. An editable page passes none. No string is new.
+
+View mode owes no sentence: the scoped inspector exists only beside a designer canvas, and a designer type enters editing whenever it can be written and has no Edit button. The no-selection default inspector (`MetadataDefaultInspectorProps`) is unchanged.
@@ -0,0 +1,243 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#29079 — the metadata editor page tells a read-only scoped
+ * inspector WHY it is read-only (`MetadataInspectorProps.readOnlyReason`), with
+ * the sentence the page's own notice gives for the cause in force.
+ *
+ * The page folds its causes into one `formReadOnly`; the inspector cannot tell
+ * them apart, so the reason is the host's. Each case opens a flow on this page,
+ * selects a node on the canvas and reads the node inspector's described group
+ * (`FlowNodeInspector`, which draws it only when a reason arrives). The walled
+ * catalog applies to the security catalog types alone, none of which ships a
+ * scoped inspector, so its case registers one for `position` through the
+ * public registry, as a host would.
+ *
+ * Stubbed: the flow and position canvases (only to emit a selection, which is
+ * the canvas's own concern) and the data reads. The page, its gates and the
+ * node inspector are real.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import * as React from 'react';
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
+import { render, screen, cleanup, fireEvent, waitFor } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import { MetadataAreaHostContext, type MetadataAreaHost } from './metadataAreaHost';
+
+const FLOW = {
+  name: 'close_case',
+  label: 'Close case',
+  type: 'autolaunched',
+  nodes: [
+    { id: 'start', type: 'start', label: 'Start' },
+    { id: 'set_status', type: 'update_record', label: 'Set status', config: { objectName: 'task', fields: { status: 'done' } } },
+    { id: 'end', type: 'end', label: 'End' },
+  ],
+  edges: [
+    { id: 'e1', source: 'start', target: 'set_status' },
+    { id: 'e2', source: 'set_status', target: 'end' },
+  ],
+};
+
+const POSITION = { name: 'sales_rep', label: 'Sales rep' };
+
+/** The layered envelope each case serves; reset per test. */
+let layered: Record<string, unknown> = {};
+let canAuthor = true;
+let walled = false;
+
+const client = {
+  list: vi.fn(async () => []),
+  listDrafts: vi.fn(async () => []),
+  get: vi.fn(async () => null),
+  getDraft: vi.fn(async () => null),
+  references: vi.fn(async () => []),
+  layered: vi.fn(async () => layered),
+  saveDraft: vi.fn(async () => ({})),
+  save: vi.fn(async () => ({})),
+};
+
+vi.mock('./useMetadata', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useMetadataClient: () => client,
+  // The registry rows as the spec declares them (`DEFAULT_METADATA_TYPE_REGISTRY`).
+  useMetadataTypes: () => ({
+    loading: false,
+    error: null,
+    entries: [
+      { type: 'flow', label: 'Flow', domain: 'automation', allowEnvironmentOverlay: false, allowRuntimeCreate: true },
+      { type: 'position', label: 'Position', domain: 'security', allowEnvironmentOverlay: false, allowRuntimeCreate: true },
+    ],
+  }),
+}));
+vi.mock('./i18n', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useMetadataLocale: () => 'en-US',
+}));
+vi.mock('../../hooks/useCanAuthorMetadata', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useCanAuthorMetadata: () => canAuthor,
+  useCanReadAuthoringTrail: () => false,
+}));
+vi.mock('./catalog-scope', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useWalledCatalogReadOnly: (type: string) => walled && type === 'position',
+}));
+vi.mock('./previews/useFlowNodePalette', () => ({
+  useActionConfigSchemas: () => ({}),
+  useFlowNodePalette: () => [],
+}));
+vi.mock('./previews/useObjectFields', () => ({
+  useObjectFields: () => ({ fields: [], loading: false, error: null }),
+}));
+
+vi.stubGlobal(
+  'fetch',
+  vi.fn(async () => new Response('not found', { status: 404 })),
+);
+
+import { MetadataResourceEditPage } from './ResourceEditPage';
+import { registerBuiltinInspectors } from './inspectors';
+import { registerMetadataPreview, getMetadataPreview, type MetadataSelection } from './preview-registry';
+import {
+  registerMetadataInspector,
+  getMetadataInspector,
+  type MetadataInspectorProps,
+} from './inspector-registry';
+import { t, tFormat } from './i18n';
+
+registerBuiltinInspectors();
+
+/** Canvas stand-in: emits the selection the real canvas emits on a click. */
+function stubCanvas(selection: MetadataSelection) {
+  return function StubCanvas({ onSelectionChange }: { onSelectionChange?: (next: MetadataSelection | null) => void }) {
+    return (
+      <button type="button" onClick={() => onSelectionChange?.(selection)}>
+        select on canvas
+      </button>
+    );
+  };
+}
+
+/** A host's inspector for a type that ships none: it draws what it is handed. */
+function HostPositionInspector({ readOnly, readOnlyReason }: MetadataInspectorProps) {
+  return (
+    <div data-testid="host-position-inspector" data-readonly={String(readOnly)}>
+      {readOnlyReason ?? ''}
+    </div>
+  );
+}
+
+const realFlowPreview = getMetadataPreview('flow');
+const realPositionPreview = getMetadataPreview('position');
+const realPositionInspector = getMetadataInspector('position');
+
+beforeEach(() => {
+  layered = { effective: FLOW, code: null, overlay: null, editable: true, deletable: true };
+  canAuthor = true;
+  walled = false;
+  registerMetadataPreview('flow', stubCanvas({ kind: 'node', id: 'set_status', label: 'Set status' }) as never);
+  registerMetadataPreview('position', stubCanvas({ kind: 'node', id: 'sales_rep', label: 'Sales rep' }) as never);
+  registerMetadataInspector('position', HostPositionInspector);
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+  if (realFlowPreview) registerMetadataPreview('flow', realFlowPreview);
+  if (realPositionPreview) registerMetadataPreview('position', realPositionPreview);
+  if (realPositionInspector) registerMetadataInspector('position', realPositionInspector);
+});
+
+const READ_ONLY_HOST: MetadataAreaHost = {
+  packageId: 'com.vendor.hr',
+  readOnly: true,
+  basePath: '/studio/com.vendor.hr/metadata',
+};
+
+/** Open the item, then select on the canvas so the scoped inspector mounts. */
+async function openAndSelect(type: string, name: string, host: MetadataAreaHost | null = null) {
+  const url = host ? `${host.basePath}/${type}/${name}` : `/apps/setup/metadata/${type}/${name}`;
+  const tree = (
+    <MemoryRouter initialEntries={[url]}>
+      <MetadataResourceEditPage type={type} name={name} />
+    </MemoryRouter>
+  );
+  render(host ? <MetadataAreaHostContext.Provider value={host}>{tree}</MetadataAreaHostContext.Provider> : tree);
+  fireEvent.click(await screen.findByRole('button', { name: 'select on canvas' }));
+}
+
+/** The node inspector's reason, as its accessible description resolves. */
+async function nodeInspectorReason(): Promise<string | null> {
+  // The inspector is mounted once its Remove-node control is.
+  await screen.findByRole('button', { name: t('engine.inspector.flowNode.remove', 'en-US') });
+  const group = document.querySelector<HTMLElement>('[data-testid="flow-node-readonly-reason"]');
+  if (!group) return null;
+  const id = group.getAttribute('aria-describedby');
+  return (id && document.getElementById(id)?.textContent) || '';
+}
+
+describe('the metadata editor page names the read-only cause to the scoped inspector (objectstack#29079)', () => {
+  it('a writable flow: the node inspector is editable and carries no reason', async () => {
+    await openAndSelect('flow', 'close_case');
+    expect(await nodeInspectorReason()).toBeNull();
+    expect(screen.getByRole('button', { name: t('engine.inspector.flowNode.remove', 'en-US') })).toBeEnabled();
+  });
+
+  it("a read-only package's area: the package is the reason, as Studio's Automations pillar says it", async () => {
+    await openAndSelect('flow', 'close_case', READ_ONLY_HOST);
+    expect(await nodeInspectorReason()).toBe(t('engine.studio.pkg.readonlyHint', 'en-US'));
+  });
+
+  it('a caller without manage_metadata: the capability is the reason', async () => {
+    canAuthor = false;
+    await openAndSelect('flow', 'close_case');
+    expect(await nodeInspectorReason()).toBe(t('engine.edit.capabilityReadOnly', 'en-US'));
+  });
+
+  it('a locked item: the lock and its served reason are the reason', async () => {
+    layered = {
+      effective: FLOW,
+      code: null,
+      overlay: null,
+      editable: false,
+      deletable: false,
+      lock: 'full',
+      lockReason: 'Managed by the release pipeline.',
+    };
+    await openAndSelect('flow', 'close_case');
+    expect(await nodeInspectorReason()).toBe(
+      `${t('engine.edit.lockFull', 'en-US')} Managed by the release pipeline.`,
+    );
+  });
+
+  it('a flow a code package ships: the package is the reason, with the way to author one', async () => {
+    layered = {
+      effective: FLOW,
+      code: { ...FLOW, _packageId: 'com.vendor.hr' },
+      overlay: null,
+      provenance: 'package',
+      packageId: 'com.vendor.hr',
+      editable: true,
+      deletable: false,
+    };
+    await openAndSelect('flow', 'close_case');
+    expect(await nodeInspectorReason()).toBe(
+      tFormat('engine.edit.artifactLockedBanner', 'en-US', { type: 'flow' }),
+    );
+  });
+
+  it("the walled security catalog: the wall is the reason, handed to a host's inspector", async () => {
+    walled = true;
+    layered = { effective: POSITION, code: null, overlay: null, editable: true, deletable: true };
+    await openAndSelect('position', 'sales_rep');
+    const inspector = await screen.findByTestId('host-position-inspector');
+    expect(inspector).toHaveAttribute('data-readonly', 'true');
+    await waitFor(() =>
+      expect(inspector).toHaveTextContent(
+        tFormat('engine.catalog.readOnly.walled', 'en-US', { type: 'Position' }),
+      ),
+    );
+  });
+});
@@ -2570,6 +2570,29 @@ function MetadataResourceEditPageImpl({
   // so its fields are not either.
   const formReadOnly = readOnly || walledDeciding || (!editing && !createMode);
 
+  // objectstack#29079 — why the scoped inspector is read-only, as the sentence
+  // the notice above the editor gives for the cause in force, in the notices'
+  // order. The inspector is shared by hosts whose causes differ, so the host
+  // names the cause (`MetadataInspectorProps.readOnlyReason`). View mode owes
+  // no sentence: the inspector exists only beside a designer canvas, and a
+  // designer type enters editing whenever it can be written (the auto-on
+  // effect above) and offers no Edit button to point at.
+  const inspectorReadOnlyReason = ((): string | undefined => {
+    if (!formReadOnly) return undefined;
+    if (walledDeciding) {
+      return tFormat('engine.catalog.readOnly.walled', locale, {
+        type: translateMetadataType(type, locale, entry?.label ?? type),
+      });
+    }
+    if (!readOnly) return undefined;
+    if (hostReadOnly) return t('engine.studio.pkg.readonlyHint', locale);
+    if (isLocked) return [lockBannerTitle(layered?.lock, locale), lockReason].filter(Boolean).join(' ');
+    if (declarationOnly) return t(`engine.catalog.declaredOnly.hint.${type}`, locale);
+    if (!canAuthor) return t('engine.edit.capabilityReadOnly', locale);
+    if (showArtifactLockedBanner) return tFormat('engine.edit.artifactLockedBanner', locale, { type });
+    return tFormat('engine.edit.readOnlyTypeBanner', locale, { flag: 'OS_METADATA_WRITABLE', type });
+  })();
+
   // Note: URL `?tab=` deep-links were repurposed to open side-panel
   // sheets (Layers / References / Related). Anything else is ignored —
   // the main work area is always the form+preview.
@@ -3490,6 +3513,7 @@ function MetadataResourceEditPageImpl({
                               setBlockingReport({ key: selectionKey, count })
                             }
                             readOnly={formReadOnly}
+                            readOnlyReason={inspectorReadOnlyReason}
                             locale={locale}
                           />
                         ) : !selection && DefaultInspectorComponent ? (