@@ -0,0 +1,18 @@
+---
+'@object-ui/plugin-detail': patch
+---
+
+fix(plugin-detail): the record history badge shows the action's option label, not the stored word upper-cased
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+A record's history tab printed each entry's stored action value in an upper-cased badge. A zh reader saw `UPDATED` and `CREATED` beside a Chinese summary, although the option's zh label was already served.
+
+What changes:
+
+- `HistoryTimeline` takes an optional `actionField` prop, `{ object, field }` (its type, `HistoryActionField`, is exported from the package entry), that names the select field its entries' `action` values come from. Each badge then shows that option's label in the active language, read through `useSafeFieldLabel().fieldOptionLabel` like any select option label on the record page.
+- `record:history` names `sys_activity.type` for the entries it fetches itself, so in zh its badges read 已更新 and 已创建.
+- A value with no label, and every value when no field is named (entries a host passes in, for example), shows as stored. Only a value shown as stored is upper-cased, so the English badges look the same as before.
+
+What to do: nothing. No metadata a page, view or object declares changes.
@@ -19,6 +19,9 @@
  * - Never re-fetches data on its own; relies on the caller to resolve
  *   `user_name` / `user_avatar` from `user_id` and to provide a pre-computed
  *   `changes` diff so this component stays presentation-only and SSR-safe.
+ * - The action badge shows the declared option label of the field the entries'
+ *   `action` values come from, when the caller names that field
+ *   (`actionField`). It holds no list of action labels of its own.
  */
 import * as React from 'react';
 import {
@@ -34,6 +37,7 @@ import {
   cn,
 } from '@object-ui/components';
 import { useDisplayLocale, useSafeTranslate } from '@object-ui/i18n';
+import { useSafeFieldLabel } from '@object-ui/react';
 import { Cog } from 'lucide-react';
 import { hasCellValue } from './emptiness';
 
@@ -59,6 +63,16 @@ export interface HistoryEntry {
   [extra: string]: unknown;
 }
 
+/**
+ * The select field an entry's `action` value is stored in, named by object and
+ * field (`{ object: 'sys_activity', field: 'type' }` for `record:history`'s
+ * self-fetch).
+ */
+export interface HistoryActionField {
+  object: string;
+  field: string;
+}
+
 export interface HistoryTimelineProps {
   entries: HistoryEntry[];
   loading?: boolean;
@@ -79,6 +93,17 @@ export interface HistoryTimelineProps {
    * (objectui#9786). Pass this only to OVERRIDE that composition.
    */
   locale?: string;
+  /**
+   * The select field the entries' `action` values come from. Each badge then
+   * shows that field's option label in the active language, read from the
+   * served translations through `useSafeFieldLabel().fieldOptionLabel`, the
+   * read the record page uses for any select option label.
+   *
+   * A value with no label there, and every value when this is not given, shows
+   * as stored. Only a value shown as stored is drawn upper-case: a translated
+   * label is drawn as the translation spells it.
+   */
+  actionField?: HistoryActionField;
 }
 
 // Kept keys mirror the server-declared `sys_audit_log.action` enum
@@ -179,13 +204,15 @@ export function HistoryTimeline({
   unknownUserText,
   className,
   locale,
+  actionField,
 }: HistoryTimelineProps) {
   // The composed tag this timeline formats with when the caller states none.
   // Read before the early returns below so the hook order never varies.
   const displayLocale = useDisplayLocale();
   const resolvedLocale = locale ?? displayLocale;
   const tt = useSafeTranslate();
   const systemActorText = tt('detail.systemActor', 'System');
+  const { fieldOptionLabel } = useSafeFieldLabel();
   if (loading) {
     return (
       <div className={cn('space-y-3', className)}>
@@ -221,6 +248,10 @@ export function HistoryTimeline({
         {entries.map((entry, idx) => {
           const action = (entry.action ?? '').toLowerCase();
           const variant = ACTION_VARIANT[action] ?? 'outline';
+          const actionLabel =
+            entry.action && actionField
+              ? fieldOptionLabel(actionField.object, actionField.field, entry.action, entry.action)
+              : entry.action;
           const resolvedName =
             (typeof entry.user_name === 'string' && entry.user_name.trim()) || '';
           // No name AND no id: nobody acted, so this is a system write, not
@@ -253,8 +284,11 @@ export function HistoryTimeline({
                 <div className="flex flex-wrap items-baseline gap-x-2 gap-y-1">
                   <span className="text-sm font-medium text-foreground">{displayName}</span>
                   {entry.action && (
-                    <Badge variant={variant} className="text-[10px] uppercase tracking-wide">
-                      {entry.action}
+                    <Badge
+                      variant={variant}
+                      className={cn('text-[10px] tracking-wide', actionLabel === entry.action && 'uppercase')}
+                    >
+                      {actionLabel}
                     </Badge>
                   )}
                   {absoluteWhen && (
 
@@ -0,0 +1,82 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * The action badge shows the declared option label of the field its entries
+ * come from (objectstack#28894).
+ *
+ * The badge printed the stored value and upper-cased it with CSS, so a zh
+ * reader saw "UPDATED" beside a Chinese summary although the option's zh label
+ * was already served. With `actionField` named, the badge reads the label the
+ * served translations give that option; a value with no label, and every value
+ * when no field is named, shows as stored. Only a stored value is upper-cased.
+ *
+ * The bundle is built with `transformSpecTranslations`, the transform the
+ * console applies to `/api/v1/i18n/translations/:locale`, so the keys are the
+ * ones the console really holds.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import { render, screen, cleanup } from '@testing-library/react';
+import { I18nProvider, transformSpecTranslations } from '@object-ui/i18n';
+import { HistoryTimeline, type HistoryEntry } from '../HistoryTimeline';
+
+const SOURCE = { object: 'sys_activity', field: 'type' } as const;
+
+const spec = (options: Record<string, string>) =>
+  transformSpecTranslations({
+    objects: { sys_activity: { label: 'Activity', fields: { type: { label: 'Type', options } } } },
+  });
+
+const RESOURCES = {
+  // The zh-CN labels plugin-audit serves for these two options.
+  zh: spec({ created: '已创建', updated: '已更新' }),
+  // The en bundle spells each option as its value.
+  en: spec({ created: 'created', updated: 'updated' }),
+};
+
+const entries: HistoryEntry[] = [
+  { id: 1, action: 'updated', user_name: 'Ada Lovelace', created_at: '2026-01-02T00:00:00.000Z' },
+  { id: 2, action: 'created', user_name: 'Ada Lovelace', created_at: '2026-01-01T00:00:00.000Z' },
+  { id: 3, action: 'assigned', user_name: 'Ada Lovelace', created_at: '2025-12-31T00:00:00.000Z' },
+];
+
+function mount(language: 'zh' | 'en', actionField?: typeof SOURCE) {
+  return render(
+    <I18nProvider config={{ defaultLanguage: language, detectBrowserLanguage: false, resources: RESOURCES }}>
+      <HistoryTimeline entries={entries} actionField={actionField} />
+    </I18nProvider>,
+  );
+}
+
+afterEach(() => cleanup());
+
+describe('HistoryTimeline action badge label (objectstack#28894)', () => {
+  it('shows the option label in zh, not the stored value, and does not upper-case it', () => {
+    mount('zh', SOURCE);
+    const updated = screen.getByText('已更新');
+    const created = screen.getByText('已创建');
+    expect(updated.className).not.toContain('uppercase');
+    expect(created.className).not.toContain('uppercase');
+    expect(screen.queryByText('updated')).toBeNull();
+    expect(screen.queryByText('created')).toBeNull();
+  });
+
+  it('shows a value with no option label as stored, upper-cased', () => {
+    mount('zh', SOURCE);
+    const assigned = screen.getByText('assigned');
+    expect(assigned.className).toContain('uppercase');
+  });
+
+  it('keeps the English look where the label is the stored word', () => {
+    mount('en', SOURCE);
+    expect(screen.getByText('updated').className).toContain('uppercase');
+    expect(screen.getByText('created').className).toContain('uppercase');
+  });
+
+  it('shows every value as stored when no source field is named', () => {
+    mount('zh');
+    expect(screen.queryByText('已更新')).toBeNull();
+    expect(screen.getByText('updated').className).toContain('uppercase');
+    expect(screen.getByText('created').className).toContain('uppercase');
+  });
+});
@@ -166,7 +166,7 @@ export type { SectionGroupProps } from './SectionGroup';
 export type { HeaderHighlightProps } from './HeaderHighlight';
 export type { RecordCommentsProps } from './RecordComments';
 export type { ActivityTimelineProps, ActivityFilterType } from './ActivityTimeline';
-export type { HistoryTimelineProps, HistoryEntry } from './HistoryTimeline';
+export type { HistoryTimelineProps, HistoryEntry, HistoryActionField } from './HistoryTimeline';
 export type { RichTextCommentInputProps, MentionSuggestion } from './RichTextCommentInput';
 export { extractMentions } from './extractMentions';
 export type { MentionTarget } from './extractMentions';
 
@@ -0,0 +1,76 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * `record:history` labels each badge from `sys_activity.type` (objectstack#28894).
+ *
+ * The block self-fetches `sys_activity` and maps each row's `type` to the
+ * entry's `action`, so the badge's source field is `sys_activity.type`. In zh
+ * the badge reads that option's served label (已更新), not the stored word
+ * upper-cased (UPDATED). Entries a host passes in name no source, so they keep
+ * the stored value.
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, cleanup } from '@testing-library/react';
+import { I18nProvider, transformSpecTranslations } from '@object-ui/i18n';
+import { RecordContextProvider } from '@object-ui/react';
+import { RecordHistoryRenderer } from '../record-history';
+
+const RESOURCES = {
+  zh: transformSpecTranslations({
+    objects: {
+      sys_activity: {
+        label: '活动',
+        fields: { type: { label: '类型', options: { created: '已创建', updated: '已更新' } } },
+      },
+    },
+  }),
+};
+
+const ROWS = [
+  { id: 'a-1', type: 'updated', summary: '更新了 线索 "Lead 1"：职位', timestamp: '2026-01-02T00:00:00.000Z' },
+  { id: 'a-2', type: 'created', summary: '创建了 线索 "Lead 1"', timestamp: '2026-01-01T00:00:00.000Z' },
+];
+
+function mount(schema: Record<string, unknown> = {}) {
+  const dataSource = { find: vi.fn(async () => ({ data: ROWS })) } as any;
+  render(
+    <I18nProvider config={{ defaultLanguage: 'zh', detectBrowserLanguage: false, resources: RESOURCES }}>
+      <RecordContextProvider
+        objectName="crm_lead"
+        recordId="rec-1"
+        data={{ id: 'rec-1', name: 'Lead 1' }}
+        dataSource={dataSource}
+      >
+        <RecordHistoryRenderer schema={schema as any} />
+      </RecordContextProvider>
+    </I18nProvider>,
+  );
+  return dataSource;
+}
+
+afterEach(() => cleanup());
+
+describe('record:history badge label (objectstack#28894)', () => {
+  it('labels self-fetched entries from sys_activity.type in zh', async () => {
+    const dataSource = mount();
+    const updated = await screen.findByText('已更新');
+    expect(updated.className).not.toContain('uppercase');
+    expect(screen.getByText('已创建')).toBeTruthy();
+    expect(screen.queryByText('updated')).toBeNull();
+    expect(dataSource.find).toHaveBeenCalledWith('sys_activity', expect.anything());
+  });
+
+  it('keeps the stored value for host-supplied entries, which name no source', () => {
+    mount({ entries: [{ id: 'h-1', action: 'updated', user_name: 'Ada Lovelace', created_at: '2026-01-02T00:00:00.000Z' }] });
+    expect(screen.getByText('updated').className).toContain('uppercase');
+    expect(screen.queryByText('已更新')).toBeNull();
+  });
+});
@@ -20,7 +20,7 @@
 
 import React from 'react';
 import { useRecordContext } from '@object-ui/react';
-import { HistoryTimeline, type HistoryEntry } from '../HistoryTimeline';
+import { HistoryTimeline, type HistoryActionField, type HistoryEntry } from '../HistoryTimeline';
 import { activityActorName } from './recordActivityFeed';
 
 const splitDesigner = (props: Record<string, any>) => {
@@ -61,6 +61,15 @@ function activityActorId(row: { actor_id?: unknown }): string | number | null {
  *  history (comments/mentions/logins are not record-history). */
 const HISTORY_TYPES = new Set(['created', 'updated', 'assigned', 'shared', 'deleted']);
 
+/**
+ * Where a self-fetched entry's `action` comes from: `sys_activity.type`, a
+ * select whose declared options carry translated labels. The timeline labels
+ * each badge from that field, so 'updated' reads as the language spells the
+ * option, not as the stored word. Host-supplied entries name no source and
+ * keep the stored value.
+ */
+const SELF_FETCH_ACTION_FIELD: HistoryActionField = { object: 'sys_activity', field: 'type' };
+
 /**
  * Rows this block shows when the author declared no usable cap.
  *
@@ -233,7 +242,13 @@ export const RecordHistoryRenderer: React.FC<RecordHistoryRendererProps> = ({
 
   return (
     <div className={className} {...designer}>
-      <HistoryTimeline entries={entries} loading={loading} emptyText={emptyText} unknownUserText={unknownUserText} />
+      <HistoryTimeline
+        entries={entries}
+        loading={loading}
+        emptyText={emptyText}
+        unknownUserText={unknownUserText}
+        actionField={hostEntries === undefined ? SELF_FETCH_ACTION_FIELD : undefined}
+      />
     </div>
   );
 };