@@ -0,0 +1,10 @@
+---
+'@object-ui/i18n': patch
+---
+
+feat(i18n): the `studio` namespace words a refused publish, and a refusal on a dashboard widget or a report input
+
+Clause-②: no
+Metadata-protocol: none
+
+- **Rows for objectstack#26730.** Studio keeps a refused publish on its Pending changes entry until it is fixed, and its "Show me" now ends on the input a refusal names. The namespace gains the sentences for that: a publish refusal (`engine.studio.refusal.publishIssue`, `publishWhere`, `publishPlain`, `publishUnlocated`), the toast that points at the sheet (`engine.studio.publishRefused`, `publishRefusedOne`, `publishRefusedBatch`), and where a dashboard widget or a report's own input is named (`engine.studio.refusal.widget`, `widgetInput`, `reportInput`). Each row has its `zh` text. No existing row changes, and no export changes.
@@ -946,6 +946,14 @@ export interface DraftChangesPanelProps {
    * publishes).
    */
   posture?: DraftChangesPosture;
+  /**
+   * objectstack#26730 — the host's note on one entry, shown under its row
+   * whether or not the row is expanded: Studio keeps a refused publish's
+   * reason here until it is resolved. Rendered by the host, so the reader that
+   * words it stays off this panel's eager graph. `null` for an entry with
+   * nothing to say.
+   */
+  renderEntryNote?: (entry: DraftChangeEntry) => ReactNode;
 }
 
 export type DraftChangesPosture = 'review' | 'confirm';
@@ -958,6 +966,7 @@ export function DraftChangesPanel({
   onPublish,
   publishing = false,
   posture = 'review',
+  renderEntryNote,
 }: DraftChangesPanelProps) {
   const { t, language } = useObjectTranslation();
   const [entries, setEntries] = useState<DraftChangeEntry[] | null>(null);
@@ -1268,6 +1277,7 @@ export function DraftChangesPanel({
                     // secondary text, or is the row's text when there is no
                     // label.
                     const labelText = resolveI18nLabel(entry.label, language)?.trim() ?? '';
+                    const note = renderEntryNote?.(entry);
                     return (
                       <li key={key} className="rounded-md border text-sm">
                         <button
@@ -1336,6 +1346,11 @@ export function DraftChangesPanel({
                             </Badge>
                           ) : null}
                         </button>
+                        {note ? (
+                          <div className="border-t px-2.5 py-2" data-testid="draft-entry-note">
+                            {note}
+                          </div>
+                        ) : null}
                         {isExpanded && (
                           <div className="border-t bg-muted/20">
                             <EntryDetail
 
@@ -0,0 +1,77 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#26730 — a Pending changes entry carries the note its host gives it.
+ *
+ * The sheet is on the console's eager graph, so it does not read a refusal
+ * itself: the Studio surface hands it `renderEntryNote`, and each entry shows
+ * what that answers under its row, with every entry the host has nothing for
+ * drawn as before. The surface's side (which refusal, when it goes) is pinned
+ * in `StudioDesignSurface.publishRefusal-26730.test.tsx`.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import * as React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, render, screen, waitFor, within } from '@testing-library/react';
+
+vi.mock('@object-ui/i18n', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useObjectTranslation: () => ({
+    t: (_k: string, o?: { defaultValue?: string }) => o?.defaultValue ?? _k,
+    language: 'en',
+  }),
+}));
+
+import { DraftChangesPanel, type DraftChangeEntry } from '../DraftChangesPanel';
+
+// `flows`: a stored plural spelling, which the sheet folds before the host sees it.
+const DRAFT_ROWS = [
+  { type: 'flows', name: 'approval', packageId: 'com.x', label: 'Approval' },
+  { type: 'object', name: 'invoice', packageId: 'com.x', label: 'Invoice' },
+];
+
+const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+  const url = String(input);
+  const ok = (body: unknown) => ({ ok: true, status: 200, json: async () => body });
+  if (url.includes('/_drafts')) return ok({ drafts: DRAFT_ROWS });
+  if (/\/meta\/[a-z_]+(\?|$)/.test(url)) return ok([]);
+  return { ok: false, status: 404, json: async () => ({}) };
+});
+
+afterEach(() => {
+  cleanup();
+  vi.unstubAllGlobals();
+  fetchMock.mockClear();
+});
+
+async function renderPanel(renderEntryNote?: (entry: DraftChangeEntry) => React.ReactNode) {
+  vi.stubGlobal('fetch', fetchMock as unknown as typeof fetch);
+  render(<DraftChangesPanel open onOpenChange={() => {}} packageId="com.x" renderEntryNote={renderEntryNote} />);
+  await waitFor(() => expect(screen.getAllByTestId('draft-entry-toggle')).toHaveLength(DRAFT_ROWS.length));
+}
+
+/** The entry whose row holds `text`. */
+function entryOf(text: string): HTMLElement {
+  return screen.getByText(text).closest('[data-testid="draft-entry-toggle"]')!.parentElement as HTMLElement;
+}
+
+describe('a Pending changes entry shows the note its host gives it (objectstack#26730)', () => {
+  it('under the entry it is for, and only there', async () => {
+    const seen: string[] = [];
+    await renderPanel((entry) => {
+      seen.push(`${entry.type}/${entry.name}`);
+      return entry.name === 'approval' ? <p>Not published. Check the step “Notify”.</p> : null;
+    });
+    // The host is asked with the folded type.
+    expect(seen).toContain('flow/approval');
+    const note = within(entryOf('Approval')).getByTestId('draft-entry-note');
+    expect(note).toHaveTextContent('Not published. Check the step “Notify”.');
+    expect(within(entryOf('Invoice')).queryByTestId('draft-entry-note')).toBeNull();
+  });
+
+  it('CONTROL: with no host note, no entry draws one', async () => {
+    await renderPanel();
+    expect(screen.queryByTestId('draft-entry-note')).toBeNull();
+  });
+});
@@ -0,0 +1,164 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#26730 — the Automations strip's "Show me" ends on the input.
+ *
+ * Measured before this card: "Show me" selected the step the refusal names
+ * and stopped there, so the focus stayed on the button and the author still
+ * had to find the input. It now ends on the input the sentence names: the
+ * step's Title for `nodes.2.config.title`, and the step's first input when
+ * the sentence names the step alone.
+ *
+ * The harness is `AutomationsPillar.authorRefusal-11785.test.tsx`'s: the real
+ * registered `FlowPreview` and `FlowInspector`, and a server double whose
+ * `save` refuses, driven through the header switch.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import * as React from 'react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, fireEvent, cleanup, waitFor, within } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+
+const PKG = 'com.acme.app';
+
+const FLOW = {
+  name: 'approval',
+  label: 'Approval',
+  type: 'autolaunched',
+  status: 'active',
+  nodes: [
+    { id: 'start', type: 'start', label: 'Start' },
+    { id: 'route', type: 'decision', label: 'Route' },
+    { id: 'tell', type: 'notify', label: 'Notify approver', config: { recipients: ['owner'] } },
+    { id: 'end', type: 'end', label: 'End' },
+  ],
+  edges: [
+    { id: 'e1', source: 'start', target: 'route' },
+    { id: 'e2', source: 'route', target: 'tell' },
+    { id: 'e3', source: 'tell', target: 'end' },
+  ],
+};
+
+const MISSING = 'Invalid input: expected string, received undefined';
+
+const server = vi.hoisted(() => ({
+  /** The issues the next draft save is refused with. */
+  issues: [] as Array<{ path: string; message: string }>,
+}));
+
+const mockClient = vi.hoisted(() => ({
+  list: vi.fn(async () => [{ name: 'approval', label: 'Approval' }]),
+  listDrafts: vi.fn(async () => []),
+  listTypes: vi.fn(async () => ({ entries: [] })),
+  get: vi.fn(async () => null),
+  references: vi.fn(async () => []),
+  layered: vi.fn(async () => ({
+    code: null,
+    overlay: null,
+    overlayScope: null,
+    effective: JSON.parse(JSON.stringify(FLOW)),
+    editable: true,
+    deletable: true,
+    resettable: false,
+    lock: 'none',
+  })),
+  getDraft: vi.fn(async (type: string, name: string) => {
+    throw Object.assign(new Error(`No pending draft exists for ${type}/${name}.`), { code: 'NO_DRAFT', status: 404 });
+  }),
+  save: vi.fn(async () => {
+    // The client's parsed `MetadataError`: a headline, a status, a code and
+    // the structured issues the server returned.
+    throw Object.assign(new Error(`flow/approval failed spec validation (${server.issues.length})`), {
+      status: 422,
+      code: 'INVALID_METADATA',
+      issues: server.issues,
+    });
+  }),
+  publish: vi.fn(async () => ({ success: true })),
+  reset: vi.fn(async () => ({})),
+}));
+
+vi.mock('../metadata-admin/useMetadata', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('../metadata-admin/useMetadata')>();
+  return { ...mod, useMetadataClient: () => mockClient, useMetadataTypes: () => ({ entries: [] }) };
+});
+
+vi.mock('./packages-io', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('./packages-io')>();
+  return { ...mod, fetchPackages: vi.fn(async () => []) };
+});
+
+vi.mock('@object-ui/react', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('@object-ui/react')>();
+  return { ...mod, useAdapter: () => dataSource };
+});
+
+vi.mock('sonner', () => ({ toast: { success: vi.fn(), error: vi.fn() } }));
+
+import { AutomationsPillar } from './StudioDesignSurface';
+import { createEmptyDataSource } from './__tests__/emptyDataSource';
+import { registerMetadataPreview } from '../metadata-admin/preview-registry';
+import { registerMetadataInspector } from '../metadata-admin/inspector-registry';
+import { FlowPreview } from '../metadata-admin/previews/FlowPreview';
+import { FlowInspector } from '../metadata-admin/inspectors/FlowInspector';
+import { t } from '../metadata-admin/i18n';
+
+const dataSource = createEmptyDataSource();
+
+// The pillar's `/automation/_status` probe and the inspector's catalog reads go
+// through the global `fetch`; "absent" keeps each on its documented fallback.
+vi.stubGlobal(
+  'fetch',
+  vi.fn(async () => new Response('null', { status: 404, headers: { 'content-type': 'application/json' } })),
+);
+
+registerMetadataPreview('flow', FlowPreview);
+registerMetadataInspector('flow', FlowInspector);
+
+beforeEach(() => {
+  server.issues = [];
+  for (const fn of Object.values(mockClient)) (fn as unknown as { mockClear: () => void }).mockClear();
+});
+
+afterEach(cleanup);
+
+/** Open the flow, then flip the header switch: a save that the server refuses. */
+async function refusedSave(issues: Array<{ path: string; message: string }>): Promise<HTMLElement> {
+  server.issues = issues;
+  render(
+    <MemoryRouter initialEntries={[`/studio/${PKG}/automations`]}>
+      <AutomationsPillar packageId={PKG} />
+    </MemoryRouter>,
+  );
+  const toggle = await screen.findByRole('switch', undefined, { timeout: 8000 });
+  await waitFor(() => expect(toggle).not.toBeDisabled());
+  fireEvent.click(toggle);
+  await waitFor(() => expect(mockClient.save).toHaveBeenCalledTimes(1));
+  return screen.findByTestId('studio-refusal');
+}
+
+describe('Automations page — "Show me" puts the focus on the input the refusal names (objectstack#26730)', () => {
+  it('`nodes.2.config.title`: the focus lands on the step\'s Title', async () => {
+    const strip = await refusedSave([{ path: 'nodes.2.config.title', message: MISSING }]);
+    const show = within(strip).getByRole('button', { name: t('engine.studio.refusal.show', 'en') });
+    show.focus();
+    fireEvent.click(show);
+
+    const rail = screen.getByTestId('auto-config-aside');
+    // The Title box, by the placeholder the notify table gives it (its label
+    // heads the row rather than naming the box).
+    const title = await within(rail).findByPlaceholderText('Your request was approved', undefined, { timeout: 8000 });
+    await waitFor(() => expect(document.activeElement).toBe(title));
+    expect(within(rail).getByLabelText('ID')).toHaveValue('tell');
+  });
+
+  it('a sentence naming the step alone: the focus lands in that step\'s inspector', async () => {
+    const strip = await refusedSave([{ path: 'nodes.2', message: MISSING }]);
+    fireEvent.click(within(strip).getByRole('button', { name: t('engine.studio.refusal.show', 'en') }));
+
+    const rail = screen.getByTestId('auto-config-aside');
+    await within(rail).findByLabelText('ID', undefined, { timeout: 8000 });
+    await waitFor(() => expect(rail.contains(document.activeElement)).toBe(true));
+  });
+});