@@ -0,0 +1,15 @@
+---
+'@object-ui/plugin-detail': patch
+'@object-ui/app-shell': patch
+---
+
+fix(plugin-detail): the record's meta line leaves the owner out only when the highlight strip the page actually drew carries `owner_id`, so a phone page names the owner somewhere (#28909)
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+**The owner on a phone.** The meta line under the details leaves the owner out when the strip already shows it. It used to ask the object's declared `highlightFields` (up to six), while a phone's record header draws at most four highlights after its subtitle. With `owner_id` declared fifth or sixth behind four non-text highlights, a phone page named the owner neither in the header nor in the meta line. The meta line now asks the strip the page drew, on every width: on a phone that owner is back on the meta line; on a desktop, where the strip draws it, the meta line still leaves it out.
+
+**`RecordMetaFooter` gains `drawnHighlightFields`** (optional, `readonly string[]`): the fields the host's highlight strip draws. The meta line leaves the owner out only when this list carries `owner_id`. Omitted, the strip is taken to be the object's declared highlights, as before. `RecordDetailView` hands it the `record:highlights` fields of the page it renders, which covers the phone header's shorter strip and a slotted page's own `highlights` slot.
+
+No metadata key is added or changed.
@@ -0,0 +1,204 @@
+/**
+ * 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.
+ */
+
+/**
+ * objectstack#28909 — the owner is named somewhere on the page at every width,
+ * and once. From a real `RecordDetailView` mount (the `phoneFace-27058`
+ * harness), with `owner_id` declared 5th in `highlightFields`, behind four
+ * non-text highlights (so the phone subtitle takes none of them):
+ *
+ *  - at 390 px the phone header draws four highlights after its subtitle, so
+ *    the owner is not in the strip and the meta line names it;
+ *  - at 1440 px the strip draws all five, the owner among them, and the meta
+ *    line leaves it out (objectstack#28868, the owner once).
+ */
+
+import * as React from 'react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, cleanup, waitFor } from '@testing-library/react';
+import { MemoryRouter, Route, Routes } from 'react-router-dom';
+import { MetadataCtx } from '@object-ui/react';
+import { RelatedCountStore } from '@object-ui/components';
+
+vi.mock('@object-ui/auth', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useAuth: () => ({ user: { id: 'u1', name: 'Ada', image: null }, activeOrganization: null }),
+  createAuthenticatedFetch: () => vi.fn(),
+}));
+
+vi.mock('@object-ui/collaboration', async (importOriginal) => ({
+  ...(await importOriginal<Record<string, unknown>>()),
+  useRecordPresence: () => [],
+  PresenceAvatars: () => null,
+}));
+
+vi.mock('sonner', () => ({
+  toast: Object.assign(vi.fn(), {
+    success: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+    warning: vi.fn(),
+    loading: vi.fn(),
+    dismiss: vi.fn(),
+  }),
+}));
+
+vi.mock('./ActionConfirmDialog', () => ({ ActionConfirmDialog: () => null }));
+vi.mock('./ActionParamDialog', () => ({ ActionParamDialog: () => null }));
+vi.mock('./ActionResultDialog', () => ({ ActionResultDialog: () => null }));
+vi.mock('./FlowRunner', () => ({ FlowRunner: () => null }));
+vi.mock('./MetadataInspector', () => ({
+  MetadataPanel: () => null,
+  useMetadataInspector: () => ({ showDebug: false, toggle: () => {} }),
+}));
+
+import { RecordDetailView } from './RecordDetailView';
+
+const APP = 'demo';
+const LEAD = 'crm_lead';
+
+const OBJECTS = [
+  {
+    name: LEAD,
+    label: 'Lead',
+    pluralLabel: 'Leads',
+    fields: {
+      id: { type: 'text', label: 'Id' },
+      name: { type: 'text', label: 'Name' },
+      email: { type: 'email', label: 'Email' },
+      status: { type: 'select', label: 'Status', options: [{ value: 'new', label: 'New' }] },
+      phone: { type: 'phone', label: 'Phone' },
+      website: { type: 'url', label: 'Website' },
+      owner_id: { type: 'lookup', reference: 'sys_user', label: 'Owner' },
+    },
+    // The title field first (it is the page's name, never a highlight), then
+    // four non-text highlights, then the owner, 5th.
+    highlightFields: ['name', 'email', 'status', 'phone', 'website', 'owner_id'],
+  },
+];
+
+const LEAD_ROW = {
+  name: 'Mira Costa',
+  email: 'mira@atlas.test',
+  status: 'new',
+  phone: '555-0100',
+  website: 'https://atlas.test',
+  owner_id: { id: 'u-ada', name: 'Ada Admin' },
+  created_at: '2026-10-16T00:00:00Z',
+};
+
+let rootWidth = 390;
+
+function setWidth(width: number) {
+  rootWidth = width;
+  Object.defineProperty(window, 'innerWidth', { value: width, configurable: true, writable: true });
+}
+
+function makeDataSource() {
+  return {
+    find: vi.fn(async () => ({ data: [], total: 0 })),
+    create: vi.fn(async (_o: string, row: unknown) => row),
+    findOne: vi.fn(async (_objectName: string, recordId: string) => ({ id: recordId, ...LEAD_ROW })),
+    update: vi.fn(async () => ({})),
+    delete: vi.fn(async () => ({})),
+  };
+}
+
+function metadataFor(objects: unknown[]) {
+  return {
+    objects,
+    pages: [],
+    loading: false,
+    error: null,
+    refresh: async () => {},
+    invalidate: () => {},
+    ensureType: async () => [],
+    getItem: async () => null,
+    getItemsByType: () => [],
+  } as never;
+}
+
+function mountPage() {
+  render(
+    <MemoryRouter initialEntries={[`/apps/${APP}/${LEAD}/record/r-1`]}>
+      <MetadataCtx.Provider value={metadataFor(OBJECTS)}>
+        <Routes>
+          <Route
+            path="/apps/:appName/:objectName/record/:recordId"
+            element={<RecordDetailView dataSource={makeDataSource() as never} objects={OBJECTS} onEdit={() => {}} />}
+          />
+        </Routes>
+      </MetadataCtx.Provider>
+    </MemoryRouter>,
+  );
+}
+
+/** The strip and the meta line, once both are drawn. */
+async function stripAndMetaLine(): Promise<{ strip: HTMLElement; metaLine: HTMLElement }> {
+  return waitFor(
+    () => {
+      const strip = document.querySelector('[data-highlights-face]') as HTMLElement | null;
+      const metaLine = document.querySelector('[data-testid="record-meta-footer"]') as HTMLElement | null;
+      expect(strip).toBeTruthy();
+      expect(metaLine).toBeTruthy();
+      // The record has loaded: the strip shows its values.
+      expect(strip!.textContent).toContain('mira@atlas.test');
+      return { strip: strip!, metaLine: metaLine! };
+    },
+    { timeout: 5000 },
+  );
+}
+
+const ownerEntry = (metaLine: HTMLElement) => metaLine.querySelector('[data-record-meta-owner]');
+
+beforeEach(() => {
+  cleanup();
+  setWidth(390);
+  window.localStorage.clear();
+  RelatedCountStore._reset();
+  vi.stubGlobal(
+    'fetch',
+    vi.fn(async () => new Response(JSON.stringify({ data: [] }), { status: 200, headers: { 'content-type': 'application/json' } })),
+  );
+  const measure = HTMLElement.prototype.getBoundingClientRect;
+  vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(function (this: HTMLElement) {
+    if (!this.hasAttribute('data-record-page-root')) return measure.call(this);
+    const width = rootWidth;
+    return { x: 0, y: 0, top: 0, left: 0, right: width, bottom: 800, width, height: 800, toJSON: () => ({}) } as DOMRect;
+  });
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+  setWidth(1440);
+});
+
+describe('the owner at every width, once (objectstack#28909)', () => {
+  it('on a phone: owner_id declared 5th is past the header\'s four, so the meta line names the owner', async () => {
+    mountPage();
+    const { strip, metaLine } = await stripAndMetaLine();
+    // The phone header: four highlights, the owner not among them.
+    expect(strip.children).toHaveLength(4);
+    expect(strip.textContent).not.toContain('Ada Admin');
+    const owner = ownerEntry(metaLine);
+    expect(owner).toBeTruthy();
+    expect(owner!.textContent).toContain('Ada Admin');
+  });
+
+  it('on a desktop: the strip names the owner and the meta line does not', async () => {
+    setWidth(1440);
+    mountPage();
+    const { strip, metaLine } = await stripAndMetaLine();
+    expect(strip.children).toHaveLength(5);
+    expect(strip.textContent).toContain('Ada Admin');
+    expect(ownerEntry(metaLine)).toBeNull();
+    // The rest of the meta line is still drawn.
+    expect(metaLine.querySelector('[data-record-meta-id]')!.textContent).toBe('r-1');
+  });
+});
@@ -300,6 +300,31 @@ const PAGE_NODE_PROPERTY_KEYS = ['children', 'items'] as const;
  */
 const TABS_URL_SYNC_KEYS: ReadonlySet<string> = new Set(['regions', 'components', 'children']);
 
+/**
+ * The fields the highlight strip of a synthesized record page draws: the
+ * `fields` of the `record:highlights` blocks among the page's top-level blocks,
+ * where the synthesizer places the strip (a phone's cut-short one included)
+ * and where a slotted page's own `highlights` slot lands. A field is read in
+ * either form the block accepts, a bare name or a `{ name }` entry, from the
+ * block's `properties` bag over its own keys.
+ */
+function drawnHighlightFieldsOf(page: unknown): string[] {
+  const out: string[] = [];
+  const regions = (page as { regions?: unknown } | null | undefined)?.regions;
+  for (const region of Array.isArray(regions) ? regions : []) {
+    const components = (region as { components?: unknown } | null | undefined)?.components;
+    for (const node of Array.isArray(components) ? components : []) {
+      if ((node as { type?: unknown } | null | undefined)?.type !== 'record:highlights') continue;
+      const props = { ...(node as object), ...((node as { properties?: object }).properties ?? {}) } as { fields?: unknown };
+      for (const field of Array.isArray(props.fields) ? props.fields : []) {
+        const name = typeof field === 'string' ? field : (field as { name?: unknown } | null | undefined)?.name;
+        if (typeof name === 'string' && name.length > 0 && !out.includes(name)) out.push(name);
+      }
+    }
+  }
+  return out;
+}
+
 /**
  * Whether a node of one of `types` is on screen when `page` opens with
  * `activeTab` as its `?tab=` value — that is, whether it is mounted.
@@ -4416,6 +4441,10 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
   // data), so the early `effectivePage` synth never contains it and checking
   // that tree would double-render the panel (tab + bottom fallback).
   const hasApprovalsNode = hasExplicitApprovals(renderedPage as any);
+  // The strip this page draws (objectstack#28909), handed to the meta line so
+  // it leaves the owner out only when the strip shows it: on a phone the
+  // header draws fewer highlights than the object declares.
+  const drawnHighlightFields = drawnHighlightFieldsOf(renderedPage);
 
   // objectstack#26678 / objectstack#27524 — the page as its tier lays it out:
   // the record header, then the details and the right column (动态, then the
@@ -4905,6 +4934,7 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                         data={readablePageRecord}
                         objectSchema={objectDef}
                         objectName={objectName}
+                        drawnHighlightFields={drawnHighlightFields}
                       />
                     }
                   />
@@ -4979,6 +5009,7 @@ export function RecordDetailView({ dataSource, objects, onEdit, objectNameOverri
                     data={readablePageRecord}
                     objectSchema={objectDef}
                     objectName={objectName}
+                    drawnHighlightFields={drawnHighlightFields}
                   />
                 </DefaultRecordPageContext.Provider>
               )}
 
@@ -71,7 +71,11 @@ hidden draws nothing. The console's record page (`RecordDetailView` in
 
 A host that mounts `RecordContextProvider` itself renders `RecordMetaFooter`
 once, where its page ends, with the record as `data` and the object definition
-as `objectSchema`. A `record:details` node with a `dataSource` binding (below)
+as `objectSchema`. A host that draws a highlight strip also passes
+`drawnHighlightFields`, the fields that strip actually draws: the meta line
+leaves the owner out only when that list carries `owner_id`, so a shorter strip
+(a phone's record header) never hides the owner from both places. Without it,
+the footer takes the object's declared `highlightFields` as the strip. A `record:details` node with a `dataSource` binding (below)
 shows a record the page does not, so it keeps its own footer.
 
 ### Record blocks without a record page (`dataSource`)
 
@@ -38,6 +38,14 @@ export interface RecordMetaFooterProps {
   objectSchema?: any;
   /** Object name for future i18n hooks (currently unused). */
   objectName?: string;
+  /**
+   * The fields the page's highlight strip actually draws, handed over by the
+   * host that draws it. The meta line leaves the owner out only when this
+   * list carries `owner_id`, so a strip cut short (a phone's header) never
+   * hides the owner from both places. Omitted, the strip is taken to be the
+   * object's declared highlights, as `deriveHighlightFields` reads them.
+   */
+  drawnHighlightFields?: readonly string[];
   className?: string;
 }
 
@@ -220,6 +228,7 @@ export const RecordMetaFooter: React.FC<RecordMetaFooterProps> = ({
   data,
   objectSchema,
   objectName: _objectName,
+  drawnHighlightFields,
   className,
 }) => {
   const { t } = useDetailTranslation();
@@ -248,10 +257,12 @@ export const RecordMetaFooter: React.FC<RecordMetaFooterProps> = ({
     !!(updatedAt || updatedBy) && !(updateIsSameAsCreate && (sameUser || !updatedBy));
 
   // The owner is named ONCE on the page (objectstack#28868): when the
-  // highlight strip carries the owner field, the strip names it and this line
-  // leaves it out. The strip is the object's declared highlights, read by the
-  // one function every reader of the strip asks.
-  const stripNamesOwner = deriveHighlightFields(objectSchema, null).includes(OWNER_FIELD);
+  // highlight strip the page draws carries the owner field, the strip names it
+  // and this line leaves it out. The host that draws the strip says which
+  // fields it drew; without that, the strip is the object's declared
+  // highlights, read by the one function every reader of the strip asks.
+  const stripFields = drawnHighlightFields ?? deriveHighlightFields(objectSchema, null);
+  const stripNamesOwner = stripFields.includes(OWNER_FIELD);
   const owner = v3MetaLine && !stripNamesOwner ? actorOrNone(data[OWNER_FIELD]) : undefined;
   const recordId = v3MetaLine && hasCellValue(data.id) ? String(data.id) : undefined;