@@ -0,0 +1,14 @@
+---
+'@object-ui/fields': patch
+'@object-ui/plugin-detail': patch
+'@object-ui/plugin-grid': patch
+---
+
+fix(ui): Setup record pages name a sharing rule's recipient and read its condition in words, and the audit list names a sign-in row's session by its user
+
+Clause-②: no
+Metadata-protocol: none
+
+- **`@object-ui/plugin-detail`.** The record page's highlights strip and details body hand each read face the record as `dependentValues`, as a list grid hands its row. A `recipient-picker` value is an id that means something only beside its `recipient_type`, so a sharing rule's page read the stored user id under 接收方 where its list read the user's name; it now reads the name.
+- **`@object-ui/fields`.** `widget: 'filter-condition'` has a read face of its own: a list or detail cell draws the criteria through the widget's read-only display, which says it in the object's field and option labels ("Priority equals Urgent"; an OR group joined by its word, a boolean as a word). A criteria the builder cannot represent still reads as the stored JSON, and an empty one is the empty cell. A read-only widget no longer waits for its `object_name` to say anything: without it, the fields keep their api names.
+- **`@object-ui/plugin-grid`.** A pointer cell (`referenceVia`) reads the target record with its name field expanded when that field is a reference the viewer may read, so a record named by a lookup reads as the referenced record's name: the audit list's sign-in rows name the session by its user instead of printing the user id. Any other name field is read as before, with no `$expand`.
@@ -302,6 +302,9 @@ const OBJECT_LITERAL_CENSUS: ReadonlyArray<readonly [type: string, text: string,
   // face for it, exactly as `text` does.
   ['position-ref', '[Object]', false],
   ['permission-ref', '[Object]', false],
+  // ── objectstack#30209: the criteria read face ───────────────────────────
+  // `{}` is not stored criteria text, so it reads as the text cell reads it.
+  ['filter-condition', '[Object]', false],
 ];
 
 /** A real value per type — the POPULATED half, which refuses the caricature. */
@@ -364,6 +367,7 @@ const POPULATED_CENSUS: ReadonlyArray<readonly [type: string, value: unknown]> =
   ['recipient-picker', 'sales_manager'],
   ['position-ref', 'sales_manager'],
   ['permission-ref', 'admin_full_access'],
+  ['filter-condition', '{"priority":"urgent"}'],
 ];
 
 describe('objectui#8596 — an object literal is not a cell value, and these renderers invented one', () => {
 
@@ -99,8 +99,9 @@ describe('objectui#13216 — the field-face seam answers the registry face of a
 
     // No widget.
     expect(resolveFieldReadFace({ name: 'subject', type: 'text' } as any)).toBeUndefined();
-    // A widget with no read face of its own draws as its type.
-    expect(resolveFieldReadFace({ name: 'criteria', type: 'textarea', widget: 'filter-condition' } as any)).toBeUndefined();
+    // A widget with no read face of its own draws as its type. (`code`: since
+    // objectstack#30209 `filter-condition` has a face of its own.)
+    expect(resolveFieldReadFace({ name: 'snippet', type: 'textarea', widget: 'code' } as any)).toBeUndefined();
     // A non-textual base type keeps its own key, so the widget does not promote.
     expect(resolveFieldReadFace({ name: 'kind', type: 'select', widget: 'object-ref' } as any)).toBeUndefined();
     // A `format` hint promotes to a richer cell, but it is not a widget's face.
 
@@ -49,7 +49,9 @@ describe('objectui#12613 — the declared widget picks the cell key', () => {
     // Controls: no widget, a widget with no read cell of its own, and a
     // non-textual base type keep the answer they had.
     expect(resolveCellRendererType({ type: 'text' })).toBe('text');
-    expect(resolveCellRendererType({ type: 'textarea', widget: 'filter-condition' })).toBe('textarea');
+    // (`code`: since objectstack#30209 `filter-condition` has a read cell.)
+    expect(resolveCellRendererType({ type: 'textarea', widget: 'code' })).toBe('textarea');
+    expect(resolveCellRendererType({ type: 'textarea', widget: 'filter-condition' })).toBe('filter-condition');
     expect(resolveCellRendererType({ type: 'select', widget: 'object-ref' })).toBe('select');
     // The widget wins over a `format` hint on the same text field: it names
     // what the value IS, the hint only how plain text is drawn.
 
@@ -3692,11 +3692,13 @@ const TEXTUAL_BASE_TYPES = new Set(['text', 'textarea', 'string', 'longtext', ''
  *
  * Only a widget listed here promotes, and only over a textual base type, the
  * same bound the `format` hints keep: a widget with no read face of its own
- * (`filter-condition`, …) still draws as its `type`.
+ * still draws as its `type`. `filter-condition` is not a reference: its face
+ * draws the stored criteria as a sentence instead of JSON.
  */
 const WIDGET_CELL_RENDERER_TYPES: ReadonlySet<string> = new Set([
   'object-ref',
   'recipient-picker',
+  'filter-condition',
   'position-ref',
   'permission-ref',
 ]);
@@ -4417,6 +4419,7 @@ export function getCellRenderer(fieldType: string): React.FC<CellRendererProps>
 }
 
 import { PositionRefCell, PermissionRefCell } from './widgets/RegistryRefCell.js';
+import { FilterConditionCell } from './widgets/FilterConditionCell.js';
 // Register standard renderers immediately
 registerFieldRenderer('lookup', LookupCellRenderer);
 registerFieldRenderer('master_detail', LookupCellRenderer);
@@ -4442,6 +4445,9 @@ registerFieldRenderer('recipient-picker', TextCellRenderer);
 // source and type, which `check:eager-closure` weighs with the rest of it.
 registerFieldRenderer('position-ref', PositionRefCell);
 registerFieldRenderer('permission-ref', PermissionRefCell);
+// The criteria key draws its sentence through the widget's own read display,
+// loaded lazily on the first cell that shows one (the stored text until then).
+registerFieldRenderer('filter-condition', FilterConditionCell);
 // `owner` was registered here to the same UserCellRenderer until objectui#4814
 // retired the spelling — see the TOMBSTONE below. `getCellRenderer('owner')`
 // now reports the prescription and falls to the text cell.
 
@@ -0,0 +1,61 @@
+/**
+ * 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.
+ */
+
+/**
+ * The READ face of the `filter-condition` key: a list or detail cell of a
+ * textual field declaring `widget: 'filter-condition'`
+ * (`resolveCellRendererType`) draws the criteria the way the widget's own
+ * read-only display does, as a sentence in the object's field and option
+ * labels (`优先级 等于 紧急`), instead of the stored JSON. The object the
+ * criteria is scoped to is the row's `object_name`, so the face reads
+ * `dependentValues`, as the `recipient-picker` face does.
+ *
+ * The widget module loads LAZILY, on the first cell that draws one, so a page
+ * that shows no criteria pays nothing; until it arrives the cell draws the
+ * stored text, exactly what the text cell drew.
+ */
+
+import React from 'react';
+import { EmptyValue } from '@object-ui/components';
+import { isEmptyValue } from '@object-ui/core';
+import { coerceToSafeValue } from '../coerceToSafeValue.js';
+import type { CellRendererProps } from '../index.js';
+
+const LazyFilterConditionField = React.lazy(() =>
+  import('./FilterConditionField.js').then((m) => ({ default: m.FilterConditionField })),
+);
+
+function StoredText({ text }: { text: string }) {
+  return (
+    <span className="block truncate" title={text}>
+      {text}
+    </span>
+  );
+}
+
+export function FilterConditionCell({ value, field, dependentValues }: CellRendererProps) {
+  const safe = coerceToSafeValue(value);
+  if (isEmptyValue(safe)) return <EmptyValue />;
+  const text = String(safe);
+  // The key's storage is JSON text (a `textarea`); any other value is not a
+  // stored criteria and reads as the text cell reads it.
+  if (typeof value !== 'string') return <StoredText text={text} />;
+  return (
+    <React.Suspense fallback={<StoredText text={text} />}>
+      <LazyFilterConditionField
+        value={value}
+        onChange={ignoreChange}
+        readonly
+        field={field}
+        dependentValues={dependentValues}
+      />
+    </React.Suspense>
+  );
+}
+
+function ignoreChange(): void {}
@@ -3,8 +3,45 @@ import { FilterBuilder, cn } from '@object-ui/components';
 import { SchemaRendererContext } from '@object-ui/react';
 import type { FieldWidgetComponentProps } from './types.js';
 import { toDomProps } from './toDomProps.js';
+import { createSafeTranslation } from '@object-ui/i18n';
 import { useFieldTranslation } from './useFieldTranslation.js';
 
+/**
+ * The words a read-only criteria is said in: the filter builder's own
+ * operator, AND / OR and boolean rows, so the sentence names each operator as
+ * the builder's dropdown does. The English rows are the provider-less render's
+ * stand-in, the same values as the `en` pack.
+ */
+const useCriteriaWordsTranslation = createSafeTranslation(
+  {
+    'filterBuilder.and': 'AND',
+    'filterBuilder.or': 'OR',
+    'filterBuilder.trueLabel': 'True',
+    'filterBuilder.falseLabel': 'False',
+    'filterBuilder.operators.equals': 'Equals',
+    'filterBuilder.operators.not_equals': 'Does not equal',
+    'filterBuilder.operators.contains': 'Contains',
+    'filterBuilder.operators.icontains': 'Contains (ignore case)',
+    'filterBuilder.operators.not_contains': 'Does not contain',
+    'filterBuilder.operators.is_empty': 'Is empty',
+    'filterBuilder.operators.is_not_empty': 'Is not empty',
+    'filterBuilder.operators.greater_than': 'Greater than',
+    'filterBuilder.operators.less_than': 'Less than',
+    'filterBuilder.operators.greater_than_or_equal': 'Greater than or equal',
+    'filterBuilder.operators.less_than_or_equal': 'Less than or equal',
+    'filterBuilder.operators.between': 'Between',
+    'filterBuilder.operators.in': 'In',
+    'filterBuilder.operators.not_in': 'Not in',
+    'filterBuilder.operators.starts_with': 'Starts with',
+    'filterBuilder.operators.ends_with': 'Ends with',
+    'filterBuilder.operators.is_null': 'Is null',
+    'filterBuilder.operators.is_not_null': 'Is not null',
+    'filterBuilder.operators.exists': 'Is set',
+    'filterBuilder.operators.notExists': 'Is not set',
+  },
+  'filterBuilder.operators.equals',
+);
+
 /**
  * FilterConditionField — visual criteria builder for a stored FilterCondition
  * (e.g. `sys_sharing_rule.criteria_json`), scoped to the object chosen in a
@@ -565,6 +602,56 @@ export function isMatchAllCriteria(parsed: any): boolean {
   return true;
 }
 
+/** Builder operators that take no comparand: the row reads "FIELD OPERATOR". */
+const VALUELESS_OPERATORS: ReadonlySet<string> = new Set([
+  'is_empty', 'is_not_empty', 'is_null', 'is_not_null', 'exists', 'notExists',
+]);
+
+/**
+ * One builder row in words: the field's label, the operator's label and the
+ * comparand as the field draws it (an option's label for a select, the boolean
+ * words for a boolean, both bounds for a range). A field the schema does not
+ * list keeps its api name, and a value no option holds stays as stored, so the
+ * sentence never invents a label.
+ */
+function describeCondition(
+  cond: BuilderCondition,
+  fieldByName: ReadonlyMap<string, FilterFieldDef>,
+  t: (key: string) => string,
+): string {
+  const def = fieldByName.get(cond.field);
+  const parts = [def?.label || cond.field, t(`filterBuilder.operators.${cond.operator}`)];
+  if (VALUELESS_OPERATORS.has(cond.operator)) return parts.join(' ');
+  const word = (v: unknown): string => {
+    if (typeof v === 'boolean') return t(v ? 'filterBuilder.trueLabel' : 'filterBuilder.falseLabel');
+    const option = def?.options?.find((o) => o.value === String(v));
+    return option ? option.label : stringifyValue(v as string | object | null | undefined);
+  };
+  const value = cond.value;
+  if (cond.operator === 'between' && Array.isArray(value)) {
+    parts.push(`${word(value[0])} – ${word(value[1])}`);
+  } else if (Array.isArray(value)) {
+    parts.push(value.map(word).join(', '));
+  } else {
+    parts.push(word(value));
+  }
+  return parts.join(' ');
+}
+
+/**
+ * A criteria the builder can represent, as one sentence: each row in words,
+ * joined by the group's AND / OR word.
+ */
+function describeFilterGroup(
+  group: BuilderGroup,
+  fields: readonly FilterFieldDef[],
+  t: (key: string) => string,
+): string {
+  const fieldByName = new Map(fields.map((f) => [f.value, f]));
+  const joiner = ` ${t(group.logic === 'or' ? 'filterBuilder.or' : 'filterBuilder.and')} `;
+  return group.conditions.map((c) => describeCondition(c, fieldByName, t)).join(joiner);
+}
+
 function stringifyValue(value: string | object | undefined | null): string {
   if (value == null || value === '') return '';
   if (typeof value === 'string') return value;
@@ -585,6 +672,7 @@ export function FilterConditionField({
 }: FieldWidgetComponentProps<string | object>) {
   const ctx = React.useContext(SchemaRendererContext);
   const { t } = useFieldTranslation();
+  const { t: tWords } = useCriteriaWordsTranslation();
   // Cast-free context read (objectui#7912); the local stays `any` for the
   // `FieldWidgetProps.dataSource?: unknown` channel it merges with.
   const dataSource: any = props.dataSource ?? ctx?.dataSource ?? null;
@@ -689,14 +777,6 @@ export function FilterConditionField({
     onChange((mongo == null ? '' : JSON.stringify(mongo)) as any);
   };
 
-  if (!objectName) {
-    return (
-      <p className={cn('text-sm text-muted-foreground', className)}>
-        {t('fields.filterCondition.selectObjectFirst')}
-      </p>
-    );
-  }
-
   if (readonly) {
     if (!rawValue.trim()) {
       // Used to read "All records" — which was both wrong and the most
@@ -709,13 +789,31 @@ export function FilterConditionField({
         </span>
       );
     }
+    // A criteria the builder can represent reads as a sentence, in the
+    // object's field and option labels once its schema answers; one it cannot
+    // represent stays the stored JSON, so nothing is hidden or reworded.
+    if (group && group.conditions.length > 0) {
+      return (
+        <span className={cn('text-sm', className)} data-filter-condition="words" title={rawValue}>
+          {describeFilterGroup(group, fields ?? [], tWords)}
+        </span>
+      );
+    }
     return (
       <pre className={cn('overflow-x-auto rounded bg-muted/40 p-2 text-xs', className)}>
         {rawValue}
       </pre>
     );
   }
 
+  if (!objectName) {
+    return (
+      <p className={cn('text-sm text-muted-foreground', className)}>
+        {t('fields.filterCondition.selectObjectFirst')}
+      </p>
+    );
+  }
+
   return (
     <div className={cn('flex flex-col gap-2', className)}>
       {rawMode ? (
 
@@ -0,0 +1,81 @@
+/**
+ * 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.
+ */
+
+/**
+ * A stored criteria reads as words (objectstack#30209 row 2).
+ *
+ * A sharing rule's `criteria_json` declares `widget: 'filter-condition'`. Its
+ * record page drew the stored JSON, `{"priority":"urgent"}`, because the key
+ * had no read face and fell to its `textarea` type. The key now draws through
+ * the widget's read display, which says the criteria in the object's field and
+ * option labels. Red before the fix (the cell printed the JSON), green after.
+ *
+ * Two controls keep the change narrow: a criteria the builder cannot represent
+ * still reads as the stored JSON, and an empty one is the empty cell.
+ */
+
+import React from 'react';
+import { describe, it, expect, afterEach } from 'vitest';
+import { render, screen, cleanup } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { I18nProvider } from '@object-ui/i18n';
+import { SchemaRendererProvider } from '@object-ui/react';
+import { getCellRenderer, resolveCellRendererType } from '../../index';
+
+afterEach(cleanup);
+
+const TASK_SCHEMA = {
+  name: 'task',
+  fields: {
+    priority: {
+      name: 'priority',
+      label: '优先级',
+      type: 'select',
+      options: [
+        { value: 'urgent', label: '紧急' },
+        { value: 'low', label: '低' },
+      ],
+    },
+    done: { name: 'done', label: '已完成', type: 'boolean' },
+  },
+};
+
+const dataSource = { getObjectSchema: async () => TASK_SCHEMA } as any;
+
+const criteriaField = { name: 'criteria_json', label: '条件', type: 'textarea', widget: 'filter-condition' } as any;
+
+function renderCell(value: string) {
+  const Cell = getCellRenderer(resolveCellRendererType(criteriaField));
+  return render(
+    <I18nProvider config={{ defaultLanguage: 'zh', detectBrowserLanguage: false }}>
+      <SchemaRendererProvider dataSource={dataSource}>
+        <Cell value={value} field={criteriaField} dependentValues={{ object_name: 'task' }} />
+      </SchemaRendererProvider>
+    </I18nProvider>,
+  );
+}
+
+describe('a `filter-condition` value reads as words (objectstack#30209)', () => {
+  it('says one condition in the field and option labels', async () => {
+    renderCell('{"priority":"urgent"}');
+    expect(await screen.findByText('优先级 等于 紧急')).toBeInTheDocument();
+    expect(screen.queryByText('{"priority":"urgent"}')).toBeNull();
+  });
+
+  it('joins an OR group with its word and draws a boolean as a word', async () => {
+    renderCell('{"$or":[{"priority":"low"},{"done":true}]}');
+    expect(await screen.findByText('优先级 等于 低 或 已完成 等于 是')).toBeInTheDocument();
+  });
+
+  it('keeps a criteria the builder cannot represent as the stored JSON (control)', async () => {
+    const nested = '{"$or":[{"$and":[{"priority":"low"},{"done":true}]},{"priority":"urgent"}]}';
+    const { container } = renderCell(nested);
+    await screen.findByText(nested);
+    expect(container.querySelector('[data-filter-condition="words"]')).toBeNull();
+  });
+});