@@ -0,0 +1,104 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * #25916, third pass — Flow Runs' client-capability diagnostics speak the
+ * session's language.
+ *
+ * Each of the page's three panels calls one client method (`meta.getItems`,
+ * `automation.execute`, `automation.listRuns`). A client without it used to
+ * leave an English sentence in the panel's error state. The state now keeps
+ * the method's NAME and the panel words it at render through
+ * `console.developer.flowRuns.clientMethodUnavailable`, so under zh the
+ * sentence is the zh row with the method name in it. A thrown message is
+ * still drawn verbatim. Control: with no provider the English sentence is
+ * unchanged.
+ */
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import { I18nProvider } from '@object-ui/i18n';
+import { builtInLocales } from '@object-ui/i18n/locales';
+
+const CLIENT = vi.hoisted(() => ({ current: {} as Record<string, unknown> }));
+const ADAPTER = vi.hoisted(() => ({ getClient: () => CLIENT.current }));
+vi.mock('@object-ui/app-shell', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAdapter: () => ADAPTER,
+  useMetadata: () => ({ objects: [], getTypeStatus: () => 'loaded' }),
+}));
+
+// Imported after the mock so the page picks it up.
+import { FlowRunsPage } from './FlowRunsPage';
+
+afterEach(() => cleanup());
+
+const { zh } = builtInLocales;
+const zhFlow = zh.console.developer.flowRuns;
+
+/** A client that serves one flow but has no automation surface at all. */
+const NO_AUTOMATION = { meta: { getItems: async () => ({ type: 'flow', items: [{ name: 'welcome_flow' }] }) } };
+/** A client that throws from the one method it has. */
+const THROWS = { meta: { getItems: async () => { throw new Error('boom: 503'); } } };
+
+function page(language: 'zh' | null) {
+  const routed = (
+    <MemoryRouter>
+      <FlowRunsPage />
+    </MemoryRouter>
+  );
+  return render(
+    language ? (
+      <I18nProvider config={{ defaultLanguage: language, detectBrowserLanguage: false }} persistLanguage={false}>
+        {routed}
+      </I18nProvider>
+    ) : (
+      routed
+    ),
+  );
+}
+
+const unavailable = (method: string) => zhFlow.clientMethodUnavailable.replace('{{method}}', method);
+
+describe('Flow Runs client diagnostics under zh (#25916)', () => {
+  it('guard: the zh row is a real zh row', () => {
+    expect(zhFlow.clientMethodUnavailable).toMatch(/\p{Script=Han}/u);
+    expect(zhFlow.clientMethodUnavailable).toContain('{{method}}');
+  });
+
+  it('a client without meta.getItems: the flow panel says so in zh', async () => {
+    CLIENT.current = {};
+    page('zh');
+    expect(await screen.findByText(unavailable('meta.getItems'))).toBeTruthy();
+  });
+
+  it('a client without automation: the runs panel and a test run say so in zh', async () => {
+    CLIENT.current = NO_AUTOMATION;
+    page('zh');
+    expect(await screen.findByText(unavailable('automation.listRuns'))).toBeTruthy();
+    fireEvent.click(screen.getByRole('button', { name: zhFlow.runFlow }));
+    expect(await screen.findByText(unavailable('automation.execute'))).toBeTruthy();
+  });
+
+  it('a thrown message is still drawn verbatim', async () => {
+    CLIENT.current = THROWS;
+    page('zh');
+    expect(await screen.findByText('boom: 503')).toBeTruthy();
+  });
+});
+
+describe('control: with no provider the diagnostics read their English (#25916)', () => {
+  it('meta.getItems', async () => {
+    CLIENT.current = {};
+    page(null);
+    expect(await screen.findByText('meta.getItems is not available on this client')).toBeTruthy();
+  });
+
+  it('automation.listRuns and automation.execute', async () => {
+    CLIENT.current = NO_AUTOMATION;
+    page(null);
+    expect(await screen.findByText('automation.listRuns is not available on this client')).toBeTruthy();
+    fireEvent.click(screen.getByRole('button', { name: 'Run Flow' }));
+    expect(await screen.findByText('automation.execute is not available on this client')).toBeTruthy();
+  });
+});
@@ -0,0 +1,129 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * #25916, third pass — the References sheet's table headers read
+ * `engine.edit.refsCol*` from this module's own `engine.*` table (the Studio
+ * carve-out, `packages/i18n/README.md`), so a zh session reads its column
+ * names in zh where they were English literals. Control: an English session
+ * still reads From type / From name / Path.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { fireEvent, render, screen, cleanup, waitFor, within } from '@testing-library/react';
+import { MemoryRouter, Route, Routes } from 'react-router-dom';
+import { I18nProvider } from '@object-ui/i18n';
+import { t } from './i18n';
+
+const objectDef = {
+  name: 'showcase_account',
+  label: 'Account',
+  fields: [{ name: 'title', label: 'Title', type: 'text' }],
+};
+
+/** A plain packaged entry — this suite is about the References sheet only. */
+const LAYERED = {
+  code: { ...objectDef, _packageId: 'com.example.showcase', _provenance: 'package' },
+  overlay: null,
+  effective: { ...objectDef },
+  provenance: 'package',
+  packageId: 'com.example.showcase',
+  editable: true,
+  deletable: true,
+  resettable: true,
+};
+
+const referencesImpl = {
+  current: vi.fn(async () => [{ fromType: 'view', fromName: 'all_accounts', path: 'data.object' }]),
+};
+
+const mockClient = {
+  list: vi.fn(async () => []),
+  listDrafts: vi.fn(async () => []),
+  get: vi.fn(async () => null),
+  getDraft: vi.fn(async () => null),
+  layered: vi.fn(async () => LAYERED),
+  reset: vi.fn(async () => ({ success: true })),
+  references: vi.fn(async (...args: unknown[]) => referencesImpl.current(...args)),
+};
+
+vi.mock('./useMetadata', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('./useMetadata')>();
+  return {
+    ...mod,
+    useMetadataClient: () => mockClient,
+    useMetadataTypes: () => ({
+      loading: false,
+      error: null,
+      entries: [
+        {
+          type: 'object',
+          name: 'object',
+          label: 'Object',
+          allowEnvironmentOverlay: true,
+          allowRuntimeCreate: true,
+          schema: {
+            type: 'object',
+            properties: { name: { type: 'string' }, label: { type: 'string' } },
+          },
+        },
+      ],
+    }),
+  };
+});
+
+import { MetadataResourceEditPage } from './ResourceEditPage';
+
+const START_PATH = '/metadata/object/showcase_account';
+
+function editor(language: 'zh' | 'en') {
+  return render(
+    <I18nProvider config={{ defaultLanguage: language, detectBrowserLanguage: false }} persistLanguage={false}>
+      <MemoryRouter initialEntries={[START_PATH]}>
+        <Routes>
+          <Route
+            path="/metadata/:type/:name"
+            element={<MetadataResourceEditPage type="object" name="showcase_account" />}
+          />
+        </Routes>
+      </MemoryRouter>
+    </I18nProvider>,
+  );
+}
+
+/** Open the References sheet (the lazy load) and return its table's header cells. */
+async function headersIn(locale: 'zh-CN' | 'en-US') {
+  await waitFor(() => expect(mockClient.layered).toHaveBeenCalled());
+  fireEvent.click(await screen.findByTitle(t('engine.edit.references', locale)));
+  const name = await screen.findByText('all_accounts');
+  const table = name.closest('table') as HTMLElement;
+  return within(table).getAllByRole('columnheader').map((th) => th.textContent);
+}
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe('References sheet column headers (#25916)', () => {
+  it('guard: the zh rows are real zh, not English copies', () => {
+    for (const key of ['engine.edit.refsColFromType', 'engine.edit.refsColFromName', 'engine.edit.refsColPath']) {
+      expect(t(key, 'zh-CN')).not.toBe(t(key, 'en-US'));
+      expect(t(key, 'zh-CN')).toMatch(/\p{Script=Han}/u);
+    }
+  });
+
+  it('a zh session reads the column names in zh', async () => {
+    editor('zh');
+    expect(await headersIn('zh-CN')).toEqual([
+      t('engine.edit.refsColFromType', 'zh-CN'),
+      t('engine.edit.refsColFromName', 'zh-CN'),
+      t('engine.edit.refsColPath', 'zh-CN'),
+    ]);
+  });
+
+  it('control: an English session still reads From type / From name / Path', async () => {
+    editor('en');
+    expect(await headersIn('en-US')).toEqual(['From type', 'From name', 'Path']);
+  });
+});