@@ -0,0 +1,16 @@
+---
+'@object-ui/i18n': patch
+---
+
+fix(studio): the dataset inspector stores no guessed measure currency
+
+Clause-②: no
+Metadata-protocol: none
+
+Picking the "Currency" display format for a dataset measure with no currency chosen used to store `currency: 'USD'`, and the currency picker pre-selected USD. A measure's own `currency` outranks the source field's fixed currency and the tenant default, so a measure saved that way showed `$` on a tenant whose default is another currency. The inspector now guesses nothing:
+
+- **Over a `currency` field** the picker opens on "Inherit — field or organization default" and the saved measure carries no `currency` key, so it resolves the field's fixed currency, then the tenant default. A numeral format with no code over such a field reads back as Currency · inherit.
+- **Over any other field** there is nothing to inherit, so the picker offers no inherit row and asks for a code; the format kind stays Currency until one is picked.
+- **A stored `currency`**, `'USD'` included, is explicit authoring and is left as written: no migration, no rewrite on load.
+
+`@object-ui/i18n` gains `engine.inspector.dataset.currencyInherit` and `engine.inspector.dataset.currencyChoose` in the studio namespace (en, zh).
@@ -0,0 +1,139 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * objectstack#27156 — the dataset inspector never guesses a measure currency.
+ *
+ * Picking the "Currency" display format used to store `currency: 'USD'` when no
+ * code was chosen, and the picker pre-selected USD. A measure's own `currency`
+ * outranks both the source field's fixed currency and the tenant default in the
+ * analytics chain, so a CNY tenant's dashboard showed `$` with no error. The
+ * ruling (no surface guesses a currency) makes the empty pick the default and
+ * stores no `currency` key at all, so the measure inherits.
+ *
+ *   - empty pick over a `currency` field ⇒ the measure carries no `currency`
+ *     key (not `undefined`, not `''`), and the picker reads "inherit";
+ *   - CONTROL: a picked CNY is stored as `currency: 'CNY'`;
+ *   - a stored `currency: 'USD'` is explicit authoring and round-trips as is;
+ *   - a measure over a plain number field has nothing to inherit: no "inherit"
+ *     row, the picker asks for a code, and the kind stays "Currency" meanwhile;
+ *   - on load, a code-less numeral format over a `currency` field reads back as
+ *     "Currency · inherit" — CONTROL: the same format over a number field reads
+ *     back as "Number".
+ *
+ * Ablation: restoring `currency || 'USD'` in `buildMeasureFormat` turns the
+ * first case red. Run recorded on the PR.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import * as React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+vi.mock('./useDatasetFields', () => ({
+  useObjectOptions: () => ({ options: [], loading: false }),
+  useDatasetFieldCatalog: () => ({
+    relationships: [],
+    fieldOptions: [
+      { value: 'amount', label: 'Amount', type: 'currency' },
+      { value: 'quantity', label: 'Quantity', type: 'number' },
+    ],
+    loading: false,
+  }),
+  useDatasetUsage: () => ({ reports: 0, dashboards: 0, loading: false }),
+  fieldTypeToDimensionType: (t: string) => (t === 'date' ? 'date' : 'string'),
+}));
+
+import { DatasetDefaultInspector } from './DatasetDefaultInspector';
+
+afterEach(cleanup);
+
+type Draft = { measures: Array<Record<string, unknown>> } & Record<string, unknown>;
+
+const draftWith = (measure: Record<string, unknown>): Draft => ({
+  name: 'sales',
+  label: 'Sales',
+  object: 'opportunity',
+  dimensions: [{ name: 'stage', field: 'stage', type: 'string' }],
+  measures: [{ name: 'revenue', aggregate: 'sum', ...measure }],
+});
+
+/** Holds the draft the way the designer does, so every pick re-renders from what was written. */
+function mount(initial: Draft) {
+  const held = { current: initial };
+  const onPatch = vi.fn();
+  function Harness() {
+    const [draft, setDraft] = React.useState<Draft>(initial);
+    return (
+      <DatasetDefaultInspector
+        type="dataset"
+        name="sales"
+        locale="en-US"
+        draft={draft}
+        readOnly={false}
+        onPatch={(patch: Record<string, unknown>) => {
+          onPatch(patch);
+          setDraft((d) => (held.current = { ...d, ...patch } as Draft));
+        }}
+      />
+    );
+  }
+  render(<Harness />);
+  return { measure: () => held.current.measures[0]!, onPatch };
+}
+
+const combo = (name: string) => screen.getByRole('combobox', { name });
+
+async function pick(name: string, option: string | RegExp) {
+  await userEvent.click(combo(name));
+  await userEvent.click(await screen.findByRole('option', { name: option }));
+}
+
+describe('dataset inspector stores no guessed measure currency (objectstack#27156)', () => {
+  it('stores no currency key when Currency is picked with no code', async () => {
+    const { measure } = mount(draftWith({ field: 'amount' }));
+    await pick('Display format', /^Currency/);
+    expect(measure()).not.toHaveProperty('currency');
+    expect(measure().format).toBe('0,0');
+    expect(combo('Display format')).toHaveTextContent(/^Currency/);
+    expect(combo('Currency')).toHaveTextContent('Inherit — field or organization default');
+  });
+
+  it('CONTROL: stores a picked CNY', async () => {
+    const { measure } = mount(draftWith({ field: 'amount' }));
+    await pick('Display format', /^Currency/);
+    await pick('Currency', 'CNY (¥)');
+    expect(measure()).toMatchObject({ format: '0,0', currency: 'CNY' });
+  });
+
+  it('round-trips a stored currency USD unchanged', async () => {
+    const { measure, onPatch } = mount(draftWith({ field: 'amount', format: '0,0.00', currency: 'USD' }));
+    expect(onPatch).not.toHaveBeenCalled();
+    expect(combo('Currency')).toHaveTextContent('USD ($)');
+    await pick('Decimals', '0');
+    expect(measure()).toMatchObject({ format: '0,0', currency: 'USD' });
+  });
+
+  it('asks for a code over a plain number field and keeps the Currency kind meanwhile', async () => {
+    const { measure } = mount(draftWith({ field: 'quantity' }));
+    await pick('Display format', /^Currency/);
+    expect(measure()).not.toHaveProperty('currency');
+    expect(combo('Display format')).toHaveTextContent(/^Currency/);
+    expect(combo('Currency')).toHaveTextContent('Choose a currency');
+    await userEvent.click(combo('Currency'));
+    const listbox = await screen.findByRole('listbox');
+    expect(within(listbox).queryByRole('option', { name: /^Inherit/ })).toBeNull();
+  });
+
+  it('reads a code-less format over a currency field back as Currency · inherit', () => {
+    mount(draftWith({ field: 'amount', format: '0,0.00' }));
+    expect(combo('Display format')).toHaveTextContent(/^Currency/);
+    expect(combo('Currency')).toHaveTextContent('Inherit — field or organization default');
+  });
+
+  it('CONTROL: reads the same format over a number field back as Number', () => {
+    mount(draftWith({ field: 'quantity', format: '0,0.00' }));
+    expect(combo('Display format')).toHaveTextContent(/^Number/);
+    expect(screen.queryByRole('combobox', { name: 'Currency' })).toBeNull();
+  });
+});
@@ -166,6 +166,21 @@ export function writeRowField<T extends { field?: string }>(row: T, field: strin
   return (isBlankField(field) ? rest : { ...rest, field }) as T;
 }
 
+/**
+ * Write a measure's display format: a key the picker leaves unset is removed
+ * rather than stored as `undefined`, the same rule as {@link writeRowField}, so
+ * the held draft and the body the save sends say the same thing — a measure on
+ * "inherit" carries no `currency` key at all.
+ */
+function writeMeasureFormat<T extends { format?: string; currency?: string }>(row: T, next: { format?: string; currency?: string }): T {
+  const { format: _format, currency: _currency, ...rest } = row;
+  return {
+    ...rest,
+    ...(next.format ? { format: next.format } : {}),
+    ...(next.currency ? { currency: next.currency } : {}),
+  } as T;
+}
+
 function SectionHeader({ title, count, onAdd, addLabel }: { title: string; count: number; onAdd?: () => void; addLabel: string }) {
   return (
     <div className="flex items-center justify-between">
@@ -197,23 +212,39 @@ function Advanced({ children, locale }: { children: React.ReactNode; locale: Sup
   );
 }
 
-/** Best-effort parse of a stored measure format into the picker's {kind, decimals}. */
-function parseMeasureFormat(format?: string, currency?: string): { kind: string; decimals: number } {
+/**
+ * Best-effort parse of a stored measure format into the picker's {kind, decimals}.
+ *
+ * `monetaryField` — the measure aggregates a `currency`-type field. Such a
+ * measure is monetary at runtime whether or not it names a `currency` (the
+ * analytics service resolves one from the field's fixed currency, then the
+ * tenant default), so a numeral format with no code reads back as "Currency ·
+ * inherit" — the state the picker wrote — rather than as a plain number.
+ */
+function parseMeasureFormat(format?: string, currency?: string, monetaryField = false): { kind: string; decimals: number } {
   const f = (format ?? '').trim();
   const m = f.match(/\.(0+)/);
   const decimals = m ? Math.min(m[1].length, 2) : 0;
   if (currency || /[$£€¥₹]/.test(f)) return { kind: 'currency', decimals };
+  if (monetaryField && f && !f.includes('%')) return { kind: 'currency', decimals };
   if (f.includes('%')) return { kind: 'percent', decimals };
   if (f) return { kind: 'number', decimals };
   return { kind: 'raw', decimals: 0 };
 }
 
-/** Generate {format, currency} from the picker selection. */
+/**
+ * Generate {format, currency} from the picker selection.
+ *
+ * An empty currency stays empty: no surface guesses a code. A measure with no
+ * `currency` inherits through the existing chain — the source field's fixed
+ * currency, then the tenant default — where a guessed `'USD'` would outrank
+ * both and show `$` on a CNY tenant's dashboard.
+ */
 function buildMeasureFormat(kind: string, decimals: number, currency: string): { format?: string; currency?: string } {
   const dp = decimals > 0 ? '.' + '0'.repeat(decimals) : '';
   switch (kind) {
     case 'number': return { format: `0,0${dp}`, currency: undefined };
-    case 'currency': return { format: `0,0${dp}`, currency: currency || 'USD' };
+    case 'currency': return { format: `0,0${dp}`, currency: currency || undefined };
     case 'percent': return { format: `0${dp}%`, currency: undefined };
     default: return { format: undefined, currency: undefined };
   }
@@ -224,10 +255,27 @@ function buildMeasureFormat(kind: string, decimals: number, currency: string): {
  * ⇄ the spec's `format`/`currency` strings and shows a live sample so a business
  * user never has to hand-write a numeral pattern.
  */
-function MeasureFormatField({ measure, onPatch, disabled, locale }: { measure: Measure; onPatch: (p: Partial<Measure>) => void; disabled?: boolean; locale: SupportedLocale }) {
-  const { kind, decimals } = parseMeasureFormat(measure.format, measure.currency);
-  const currency = measure.currency || 'USD';
-  const apply = (k: string, d: number, c: string) => onPatch(buildMeasureFormat(k, d, c));
+function MeasureFormatField({ measure, monetaryField, onPatch, disabled, locale }: { measure: Measure; monetaryField: boolean; onPatch: (p: { format?: string; currency?: string }) => void; disabled?: boolean; locale: SupportedLocale }) {
+  const parsed = parseMeasureFormat(measure.format, measure.currency, monetaryField);
+  // "Currency" with no code is not distinguishable on the wire from "Number"
+  // for a measure over a plain number field, so the kind the author just picked
+  // is held for as long as the stored format is still the one that pick wrote —
+  // otherwise the select would snap back to "Number" before a code is chosen.
+  const [held, setHeld] = React.useState<{ kind: string; format?: string; currency?: string } | null>(null);
+  const kind = held && held.format === measure.format && held.currency === measure.currency ? held.kind : parsed.kind;
+  const { decimals } = parsed;
+  const currency = measure.currency ?? '';
+  const apply = (k: string, d: number, c: string) => {
+    const next = buildMeasureFormat(k, d, c);
+    setHeld({ kind: k, ...next });
+    onPatch(next);
+  };
+  // Only a measure over a `currency` field has a chain to inherit from; any
+  // other measure without a code renders as a plain number, so it is offered
+  // no "inherit" row and asks for a code instead.
+  const currencyOptions = monetaryField
+    ? [{ value: '', label: t('engine.inspector.dataset.currencyInherit', locale) }, ...CURRENCY_OPTIONS]
+    : CURRENCY_OPTIONS;
   // The sample is a PREVIEW of authored formatting, so it has to be rendered
   // through the same channel as the surfaces it previews (objectui#4575): a
   // German session picking "Number · 1 decimal" is shown `1.234,5`, because
@@ -247,7 +295,7 @@ function MeasureFormatField({ measure, onPatch, disabled, locale }: { measure: M
         )}
       </div>
       {kind === 'currency' && (
-        <InspectorSelectField label={t('engine.inspector.dataset.currency', locale)} value={currency} options={CURRENCY_OPTIONS} onCommit={(v) => apply(kind, decimals, v)} disabled={disabled} />
+        <InspectorSelectField label={t('engine.inspector.dataset.currency', locale)} value={currency} options={currencyOptions} placeholder={t('engine.inspector.dataset.currencyChoose', locale)} onCommit={(v) => apply(kind, decimals, v)} disabled={disabled} />
       )}
       {kind !== 'raw' && (
         <p className="text-[10px] text-muted-foreground">
@@ -673,7 +721,13 @@ export function DatasetDefaultInspector({ draft, onPatch, readOnly, name, locale
               {(() => { const rel = missingRelationship(m.field, include); return rel ? <RelWarning rel={rel} disabled={readOnly} locale={locale} onAdd={() => onPatch({ include: appendArray(include, rel) })} /> : null; })()}
               <Advanced locale={locale}>
                 <InspectorTextField label={tr('engine.inspector.dataset.labelOptional')} value={m.label ?? ''} onCommit={(v) => patchMeasure(i, { label: v || undefined })} placeholder={m.name || tr('engine.inspector.dataset.displayLabel')} disabled={readOnly} />
-                <MeasureFormatField measure={m} onPatch={(pp) => patchMeasure(i, pp)} disabled={readOnly} locale={locale} />
+                <MeasureFormatField
+                  measure={m}
+                  monetaryField={fieldOptions.find((o) => o.value === m.field)?.type === 'currency'}
+                  onPatch={(fmt) => onPatch({ measures: measures.map((mm, idx) => (idx === i ? writeMeasureFormat(mm, fmt) : mm)) })}
+                  disabled={readOnly}
+                  locale={locale}
+                />
                 <FilterConditionField
                   label={tr('engine.inspector.dataset.measureFilter')}
                   help={tr('engine.inspector.dataset.measureFilterHelp')}
 
@@ -1172,6 +1172,8 @@ const STUDIO_EN: Record<string, string> = {
   'engine.inspector.dataset.displayFormat': 'Display format',
   'engine.inspector.dataset.decimals': 'Decimals',
   'engine.inspector.dataset.currency': 'Currency',
+  'engine.inspector.dataset.currencyInherit': 'Inherit — field or organization default',
+  'engine.inspector.dataset.currencyChoose': 'Choose a currency',
   'engine.inspector.dataset.sample': 'Sample: {sample}',
   'engine.inspector.dataset.relWarning': "Relationship {rel} isn't in Included relationships.",
   'engine.inspector.dataset.relWarningAdd': 'Add it',
 
@@ -1046,6 +1046,8 @@ const STUDIO_ZH: Record<string, string> = {
   'engine.inspector.dataset.displayFormat': '显示格式',
   'engine.inspector.dataset.decimals': '小数位数',
   'engine.inspector.dataset.currency': '货币',
+  'engine.inspector.dataset.currencyInherit': '继承 —— 字段或组织的默认币种',
+  'engine.inspector.dataset.currencyChoose': '选择币种',
   'engine.inspector.dataset.sample': '示例：{sample}',
   'engine.inspector.dataset.relWarning': '关联 {rel} 不在「包含的关联」中。',
   'engine.inspector.dataset.relWarningAdd': '添加它',