@@ -3,23 +3,21 @@
 '@objectstack/service-analytics': minor
 ---
 
-feat(spec,service-analytics): analytics over a record-currency amount — grouped answers name a per-row currency, an ungrouped amount aggregate is refused, and two compile-time measure-currency guards (ADR-0144 D2, D6)
+feat(spec,service-analytics): analytics over a record-currency amount — grouped answers name a per-row currency, an ungrouped amount aggregate is refused, and two compile-time guards on record-mode measures (ADR-0144 D2, D6)
 
-Clause-②: yes (narrowing)
-Metadata-protocol: narrowed
+Clause-②: yes (widening)
+Metadata-protocol: added
 
 A measure column over a `currencyMode: 'record'` amount now carries `fields[].currencyField` on a `queryDataset` answer: the name of the dimension column that groups by the amount's code field. Each row's currency is that row's value of it, and the column carries no `currency`. Before, a breakdown by currency labelled every group with one code.
 
 - `AnalyticsResult.fields[].currencyField` (`@objectstack/spec/contracts`) and the same key on `AnalyticsResultResponseSchema` (`@objectstack/spec/api`).
 - The cube door refuses a `sum`, `avg`, `min` or `max` over a record-mode amount whose query does not group by the code field, with `INVALID_FIELD` / 400 naming the measure, the field and its object. A `totals` grouping that drops the code, the grand total included, is refused the same way. `count` reads no amount and is served.
 
-**BREAKING** (`@objectstack/service-analytics`): two compile-time refusals, `DATASET_INVALID` / 400, for dataset metadata that compiled before and printed a wrong label or a wrong number.
+Two compile-time refusals, `DATASET_INVALID` / 400, on the record mode alone, so nothing that compiled before is refused:
 
-- A measure `currency` that contradicts its field: a code other than the `fixed` field's own, or any code over a record-mode amount. The column printed the field's amounts under the measure's code. A code equal to the `fixed` field's is still accepted, and a measure `currency` over a `dynamic` field is not judged.
-- A derived measure whose monetary operands are in currencies that provably differ (two different codes, or a record-mode amount against anything but itself), for every op. The derived value combined bare numbers in two currencies and carried no currency at all. A count operand is not compared, so a revenue-per-deal ratio still compiles.
+- a measure `currency` over a record-mode amount, whose currency is per row;
+- a derived measure that combines a record-mode amount with an operand in another currency (another code field, a `fixed` code, an explicit code or the tenant's), for every op. A count operand is not compared, so an amount-per-invoice ratio still compiles.
 
-Each refusal names the measure and says what to delete or change. No in-tree dataset declares either shape.
-
-<!-- adr-0087: not-required (no-migration-prescription) the two refusals reject a contradiction in a dataset's own measures at compile and name the fix in their message; there is no stored shape to convert and no key is removed -->
+The same two shapes over `fixed` fields only are not judged.
 
 ⛔ Not released alone: this ships in the same release as the record currency mode, its write refusals and the per-row display.
@@ -98,12 +98,10 @@ const DATASET = DatasetSchema.parse({
     { name: 'm_nomode', aggregate: 'sum', field: 'amt_nomode' },
     { name: 'm_emptycfg', aggregate: 'sum', field: 'amt_emptycfg' },
     { name: 'm_bare', aggregate: 'sum', field: 'amt_bare' },
-    // An explicit measure `currency` wins over a dynamic field's tenant
-    // default. [ADR-0144 M0-3] Over a FIXED field it may only restate the
-    // field's code: a contradicting one is refused at compile
-    // (`measure-currency-coherence.ts`, record-currency-analytics.test.ts).
+    // An explicit measure `currency` wins over every field-side answer,
+    // the field's FIXED currency included.
     { name: 'm_explicit_dynamic', aggregate: 'sum', field: 'amt_dynamic', currency: 'JPY' },
-    { name: 'm_explicit_fixed', aggregate: 'sum', field: 'amt_fixed', currency: 'EUR' },
+    { name: 'm_explicit_fixed', aggregate: 'sum', field: 'amt_fixed', currency: 'JPY' },
     { name: 'm_units', aggregate: 'sum', field: 'units' },
   ],
 });
@@ -222,11 +220,11 @@ describe.each<Shape>(['raw', 'parsed'])('[#20091] result-column currency honours
     expect(preview.m_bare).toBe('USD');
   });
 
-  it("an explicit measure currency wins over a dynamic field, and restates a fixed one's code", () => {
+  it('an explicit measure currency wins, over a dynamic field and over a fixed one', () => {
     expect(live.m_explicit_dynamic).toBe('JPY');
     expect(preview.m_explicit_dynamic).toBe('JPY');
-    expect(live.m_explicit_fixed).toBe('EUR');
-    expect(preview.m_explicit_fixed).toBe('EUR');
+    expect(live.m_explicit_fixed).toBe('JPY');
+    expect(preview.m_explicit_fixed).toBe('JPY');
   });
 
   it('CONTROL: a non-monetary measure carries no currency', () => {
 
@@ -153,11 +153,8 @@ describe('AnalyticsService.queryDataset', () => {
     expect(r.fields.find((f: any) => f.name === 'revenue')?.currency).toBe('GBP');
   });
 
-  // [ADR-0144 M0-3] Over a FIXED field a measure currency may only restate the
-  // field's code — a contradicting one is refused at compile
-  // (`measure-currency-coherence.ts`, pinned in record-currency-analytics.test.ts).
-  it('chain: an explicit measure currency wins over the tenant ctx on a dynamic field', async () => {
-    const svc = pricedSvc([{ stage: 'Won', revenue: 1000 }], (_o, f) => f === 'amount' ? { type: 'currency' } : undefined);
+  it('chain: an explicit measure currency wins over the field default and the tenant ctx', async () => {
+    const svc = pricedSvc([{ stage: 'Won', revenue: 1000 }], (_o, f) => f === 'amount' ? { type: 'currency', defaultCurrency: 'EUR' } : undefined);
     const r = await svc.queryDataset(moneyDataset({ currency: 'JPY' }), { dimensions: ['stage'], measures: ['revenue'] }, { tenantId: 'o', currency: 'GBP' } as ExecutionContext) as any;
     expect(r.fields.find((f: any) => f.name === 'revenue')?.currency).toBe('JPY');
   });
 
@@ -19,9 +19,11 @@
  *   own capabilities; `ObjectQLStrategy`, narrowed to the engine aggregate),
  *   and the column on the draft-preview path, which shares the one
  *   column-description seam.
- * - The two compile-time guards (`measure-currency-coherence.ts`):
- *   `DATASET_INVALID` / 400 for a measure `currency` that contradicts its
- *   field, and for a derived measure across currencies that provably differ.
+ * - The two compile-time guards (`measure-currency-coherence.ts`), both on
+ *   the record mode alone: `DATASET_INVALID` / 400 for a measure `currency`
+ *   over a record-mode amount, and for a derived measure combining one with an
+ *   operand in another currency. The same shapes over `fixed` fields only
+ *   still compile (controls below).
  *
  * The SQLite cell runs everywhere; the strategies are the axis here, not the
  * dialect (the door stands ahead of both and reads nothing).
@@ -263,20 +265,13 @@ describe('[ADR-0144 M0-3] analytics over a record-currency amount', () => {
       expect(err?.message).toContain(`"${named}"`);
     };
 
-    it('a measure currency contradicting a fixed field is refused', () => {
-      expectRefused([{ name: 'eur_as_jpy', aggregate: 'sum', field: 'amt_eur', currency: 'JPY' }], 'eur_as_jpy');
-    });
-
-    it("a measure currency restating a fixed field's code is accepted", () => {
-      expect(compileRefusal([{ name: 'eur', aggregate: 'sum', field: 'amt_eur', currency: 'EUR' }])).toBeUndefined();
-    });
-
     it('a measure currency over a record-currency amount is refused', () => {
       expectRefused([{ name: 'total_usd', aggregate: 'sum', field: 'amount', currency: 'USD' }], 'total_usd');
     });
 
-    it('a measure currency over a dynamic field is not judged (the tenant currency is unknown at compile)', () => {
-      expect(compileRefusal([{ name: 'tenant_as_usd', aggregate: 'sum', field: 'amt_tenant', currency: 'USD' }])).toBeUndefined();
+    it('CONTROL: a measure currency over a fixed field is not judged, whatever its code (an ADR-0144 open item)', () => {
+      expect(compileRefusal([{ name: 'eur_as_jpy', aggregate: 'sum', field: 'amt_eur', currency: 'JPY' }])).toBeUndefined();
+      expect(compileRefusal([{ name: 'eur', aggregate: 'sum', field: 'amt_eur', currency: 'EUR' }])).toBeUndefined();
     });
 
     const base = [
@@ -288,27 +283,31 @@ describe('[ADR-0144 M0-3] analytics over a record-currency amount', () => {
     ];
 
     for (const op of ['sum', 'difference', 'ratio', 'product'] as const) {
-      it(`a derived ${op} across two fixed currencies is refused`, () => {
-        expectRefused([...base, { name: 'mixed', derived: { op, of: ['usd', 'eur'] } }], 'mixed');
+      it(`a derived ${op} of a record-currency amount and a fixed one is refused`, () => {
+        expectRefused([...base, { name: 'mixed', derived: { op, of: ['total', 'usd'] } }], 'mixed');
       });
     }
 
-    it('a derived measure across a record-currency amount and a fixed one is refused', () => {
-      expectRefused([...base, { name: 'mixed', derived: { op: 'difference', of: ['total', 'usd'] } }], 'mixed');
+    it('a derived measure of a record-currency amount and a tenant-currency one is refused', () => {
+      expectRefused([...base, { name: 'mixed', derived: { op: 'sum', of: ['tenant', 'total'] } }], 'mixed');
     });
 
-    it('a derived measure built on a mixed-currency derived sum is refused at the first mixed one', () => {
+    it('a derived measure built on a record-currency derived sum is judged at the next level', () => {
       expectRefused(
-        [...base, { name: 'usd_twice', derived: { op: 'sum', of: ['usd', 'usd'] } }, { name: 'mixed', derived: { op: 'sum', of: ['usd_twice', 'eur'] } }],
+        [...base, { name: 'total_twice', derived: { op: 'sum', of: ['total', 'total'] } }, { name: 'mixed', derived: { op: 'sum', of: ['total_twice', 'eur'] } }],
         'mixed',
       );
     });
 
-    it('accepted: one currency with a count (revenue per invoice), one fixed with the tenant (not provably different)', () => {
+    it('CONTROL: a derived measure over two different fixed codes is not judged (an ADR-0144 open item)', () => {
+      expect(compileRefusal([...base, { name: 'mixed', derived: { op: 'sum', of: ['usd', 'eur'] } }])).toBeUndefined();
+    });
+
+    it('accepted: an amount per invoice, an amount with itself, a fixed amount with the tenant currency', () => {
       expect(
         compileRefusal([
           ...base,
-          { name: 'per_invoice', derived: { op: 'ratio', of: ['usd', 'invoices'] } },
+          { name: 'per_invoice', derived: { op: 'ratio', of: ['total', 'invoices'] } },
           { name: 'usd_and_tenant', derived: { op: 'sum', of: ['usd', 'tenant'] } },
           { name: 'total_share', derived: { op: 'ratio', of: ['total', 'total'] } },
         ]),
 
@@ -854,9 +854,9 @@ export function compileDataset(
     if (m.filter) measureFilters[m.name] = m.filter;
   }
 
-  // [ADR-0144, M0-3] A measure `currency` contradicting its field, and a
-  // derived measure across differing currencies, are refused HERE: both are
-  // properties of the document, decidable from metadata before any query runs.
+  // [ADR-0144, M0-3] A measure `currency` over a record-mode amount, and a
+  // derived measure combining one with another currency, are refused HERE: both
+  // are properties of the document, decidable from metadata before any query runs.
   assertMeasureCurrenciesCoherent(dataset, options?.declaredCurrency);
 
   const cube: Cube = {
 
@@ -2,44 +2,41 @@
 
 /**
  * [ADR-0144, multi-currency M0-3] Two compile-time guards on a dataset's
- * measure currencies — the guards the measurement round on #8345 (its Q6)
- * found missing on today's surface, `DATASET_INVALID` / 400 at compile, where
- * the author still holds the document.
+ * measures over a `currencyMode: 'record'` amount, `DATASET_INVALID` / 400 at
+ * compile, where the author still holds the document. Both judge the record
+ * mode alone, a surface that ships with them, so neither refuses anything a
+ * dataset could write before.
  *
- * 1. **A measure `currency` that contradicts its field.** The column's
- *    currency chain lets an explicit measure `currency` win over everything
- *    (`enrichResultColumns`), so `currency: 'USD'` over a field fixed to `EUR`
- *    printed euros as dollars (probe A, `m_eur_as_usd`: 100 `"USD"`). Refused
- *    when the field is `fixed` to a different code, and over every
- *    `record`-mode field, whose currency is per row and so is contradicted by
- *    any one code. The same code as a `fixed` field's is redundant, not
- *    wrong, and is accepted. A `dynamic` field is not judged: its currency is
- *    the tenant's, which is not known at compile.
- * 2. **A derived measure across differing currencies.** `computeDerived` adds,
- *    subtracts, multiplies and divides bare numbers, so `sum` over a USD
- *    measure and an EUR measure answered `200` with no currency at all (probe
- *    A, `m_mixed_sum`). Refused when two of its operands are monetary and
- *    their resolved currencies provably differ, whatever the op: a ratio or a
- *    product of two amounts in two currencies is no more a number than their
- *    sum. Non-monetary operands (a `count`) are not compared, so revenue per
- *    deal stays legal.
+ * 1. **A measure `currency` over a record-mode amount.** Its currency is per
+ *    row (ADR-0144 D2), so any one code contradicts it, and the column's chain
+ *    would let the measure's code win (`enrichResultColumns`).
+ * 2. **A derived measure that combines a record-mode amount with an operand in
+ *    another currency.** `computeDerived` adds, subtracts, multiplies and
+ *    divides bare numbers, so such a value is not a number in any currency
+ *    (probe A of the #8345 measurement round, `m_mixed_sum`: `200` with no
+ *    currency). Refused, whatever the op, when a record-mode operand and another
+ *    monetary operand provably differ: another code field, a `fixed` code, an
+ *    explicit measure code or the tenant's. Non-monetary operands (a `count`)
+ *    are not compared, so an amount per invoice stays legal.
+ *
+ * ⛔ Not judged: the same two shapes over `fixed` / `dynamic` fields only — a
+ * measure `currency` contradicting a `fixed` field, a derived measure over two
+ * different `fixed` codes. Refusing those would narrow what compiles today,
+ * which neither ruling #27119 nor ADR-0144 decides; it is an ADR-0144 open item
+ * for the maintainer.
  *
  * ## The resolved currency, at compile
  *
  * The column's chain, with the request's half left symbolic: an explicit
  * measure `currency`, else the field's `fixed` code, else the tenant's (one
- * code per request, unknown here). A `record`-mode amount resolves to its code
- * field. Two currencies provably differ when they are two codes, two different
- * code fields, or a code field against anything else; the tenant's against a
- * code is NOT provably different and is not judged ("cannot answer, do not
- * block"). A derived `sum` / `difference` resolves to its operands' common
- * currency, so a derived measure built on one is judged too; a `ratio` or
- * `product` resolves to none.
+ * code per request, unknown here). A record-mode amount resolves to its code
+ * field. A derived `sum` / `difference` resolves to its operands' common
+ * currency (none when they differ), so a derived measure built on one is
+ * judged too; a `ratio` or `product` resolves to none.
  *
  * ## Not judged
  *
- * - No `declaredCurrency` hook (no data engine), or a field it cannot resolve:
- *   only an explicit measure `currency` is known then.
+ * - No `declaredCurrency` hook (no data engine), or a field it cannot resolve.
  * - A relationship-path field (`account.amount`): the hook answers for the
  *   base object, as for the aggregate × field-type door.
  * - A duration measure, which counts time, not money.
@@ -70,13 +67,18 @@ const currencyWords = (r: Resolved): string =>
       ? `each record's '${r.codeField}' (record currency)`
       : "the tenant's default currency";
 
+/** Two currencies that are provably not one: two codes, two code fields, or a code field and anything else. */
 function provablyDiffer(a: Resolved, b: Resolved): boolean {
   if (a.kind === 'record' || b.kind === 'record') {
     return !(a.kind === 'record' && b.kind === 'record' && a.codeField === b.codeField);
   }
   return a.kind === 'code' && b.kind === 'code' && a.code !== b.code;
 }
 
+/** The pair guard 2 refuses: a provable difference with a record-mode amount on one side. */
+const recordPairDiffers = (a: Resolved, b: Resolved): boolean =>
+  (a.kind === 'record' || b.kind === 'record') && provablyDiffer(a, b);
+
 /**
  * Refuse the first measure of `dataset` that breaks either guard — see the
  * module header. `declaredCurrency` answers for a bare field of the base
@@ -90,7 +92,7 @@ export function assertMeasureCurrenciesCoherent(
   const fieldOf = (m: DatasetMeasure): DeclaredCurrency | undefined =>
     m.field && !m.field.includes('.') ? declaredCurrency?.(dataset.object, m.field) : undefined;
 
-  // Guard 1 — a measure `currency` that contradicts its field.
+  // Guard 1 — a measure `currency` over a record-mode amount.
   for (const m of dataset.measures) {
     if (m.derived || m.duration || !m.currency || !m.field) continue;
     const field = fieldOf(m);
@@ -103,17 +105,9 @@ export function assertMeasureCurrenciesCoherent(
         + 'row carries its own.',
       );
     }
-    if (field?.defaultCurrency !== undefined && field.defaultCurrency !== m.currency) {
-      throw datasetInvalidError(
-        `[dataset-compiler] dataset "${dataset.name}" measure "${m.name}" declares currency "${m.currency}" `
-        + `over field "${m.field}", which object "${dataset.object}" fixes to ${field.defaultCurrency}. The `
-        + `amounts are ${field.defaultCurrency}, so the column would print them as ${m.currency}: delete the `
-        + `measure's \`currency\` (the column takes the field's ${field.defaultCurrency}).`,
-      );
-    }
   }
 
-  // Guard 2 — a derived measure across differing currencies.
+  // Guard 2 — a derived measure combining a record-mode amount with another currency.
   const memo = new Map<string, Resolved | undefined>();
   const resolving = new Set<string>();
   const resolvedOf = (m: DatasetMeasure): Resolved | undefined => {
@@ -148,9 +142,10 @@ export function assertMeasureCurrenciesCoherent(
   for (const m of dataset.measures) {
     if (!m.derived) continue;
     const operands = monetaryOperands(m);
-    const first = operands[0];
-    const other = operands.find((o) => first && provablyDiffer(o.resolved, first.resolved));
-    if (!first || !other) continue;
+    const pair = operands.flatMap((a, i) => operands.slice(i + 1).map((b) => [a, b] as const))
+      .find(([a, b]) => recordPairDiffers(a.resolved, b.resolved));
+    if (!pair) continue;
+    const [first, other] = pair;
     throw datasetInvalidError(
       `[dataset-compiler] dataset "${dataset.name}" derived measure "${m.name}" (${m.derived.op}) combines `
       + `measure "${first.name}", in ${currencyWords(first.resolved)}, with measure "${other.name}", in `