@@ -81,6 +81,7 @@ import { measureResultType } from './measure-result-type.js';
 // `ensureCube`, ahead of both strategies, as the dataset door refuses it at
 // compile.
 import { assertCubeMeasureFieldTypesAccepted, type MeasureColumn } from './cube-measure-field-type-door.js';
+import { assertRecordCurrencyAggregatesGrouped } from './cube-record-currency-door.js';
 import type { AnalyticsStrategy, AnalyticsDriverCapabilities, StrategyContext, DatasetScopedStrategyContext, DatasetScope, ReadScopeFilterJudge } from './strategies/types.js';
 import { NativeSQLStrategy } from './strategies/native-sql-strategy.js';
 import { ObjectQLStrategy } from './strategies/objectql-strategy.js';
@@ -1134,6 +1135,12 @@ export interface AnalyticsServiceConfig {
    *   naming no mode, `dynamic` by the spec's default — has no field-level
    *   currency; the tenant default applies. `AnalyticsServicePlugin`'s relay
    *   is the reference answer.
+   *   [ADR-0144 D2] `currencyField` is the code field of a `record`-mode
+   *   amount: answer `currencyConfig.currencyField` ONLY when
+   *   `currencyConfig.currencyMode` is `'record'`, and `undefined` otherwise.
+   *   Such an amount has one currency per ROW, so its column carries the
+   *   `currencyField` pointer instead of a `currency`, and the cube door
+   *   refuses an aggregate of it that does not group by that field.
    * - Percent scale (objectui#3136): a measure over a `percent` field inherits
    *   that field's storage scale via `percentScaleOf`, so a renderer scales by
    *   declared metadata instead of guessing from the value.
@@ -1163,7 +1170,7 @@ export interface AnalyticsServiceConfig {
   sourceFieldMeta?: (
     object: string,
     field: string,
-  ) => { type?: string; multiple?: boolean; defaultCurrency?: string; max?: number } | undefined;
+  ) => { type?: string; multiple?: boolean; defaultCurrency?: string; currencyField?: string; max?: number } | undefined;
   /**
    * [#15684] The SQL dialect of the datasource backing `object` — `'sqlite'`,
    * `'postgres'`, `'mysql'`, or `undefined` when the host cannot answer.
@@ -2549,6 +2556,13 @@ export class AnalyticsService implements IAnalyticsService {
         if (typeof meta?.type !== 'string' || meta.type === '') return undefined;
         return { type: meta.type, multiple: meta.multiple === true };
       },
+      // [ADR-0144, M0-3] …and the declared currency off the same hook, so the
+      // compile-time currency guards judge exactly what the column would print.
+      declaredCurrency: (object: string, field: string) => {
+        const meta = this.sourceFieldMeta?.(object, field);
+        if (!meta) return undefined;
+        return { type: meta.type, defaultCurrency: meta.defaultCurrency, currencyField: meta.currencyField };
+      },
     });
   }
 
@@ -3158,10 +3172,24 @@ export class AnalyticsService implements IAnalyticsService {
         // A measure is monetary if it declares a currency OR aggregates a
         // `currency`-type field; non-monetary measures (count, avg of a plain
         // number) never receive a currency code.
-        const fc = f as { currency?: string };
+        //
+        // [ADR-0144 D2] A `record`-mode amount has one currency per ROW, held
+        // in its code field, so no single code describes the column and no
+        // step of the chain is asked. The column names, by `currencyField`,
+        // the selected dimension that groups by that code field: each row's
+        // currency is that row's value of it. Read off the dataset and the
+        // declaration like every key here, never off the rows. The cube door
+        // has already refused an amount aggregate that drops the grouping; a
+        // column left without the dimension (a `count` over the amount) gets
+        // neither key, rather than a label that is wrong for every other row.
+        const fc = f as { currency?: string; currencyField?: string };
         const mc = m as { currency?: string };
         const meta = m.field ? this.sourceFieldMeta?.(dataset.object, m.field) : undefined;
-        if (fc.currency == null) {
+        if (meta?.currencyField !== undefined) {
+          const codeColumn = this.selectedDimensions(dataset, selection)
+            .find((d) => d.field === meta.currencyField)?.name;
+          if (fc.currencyField == null && codeColumn !== undefined) fc.currencyField = codeColumn;
+        } else if (fc.currency == null) {
           const monetary = !!mc.currency || meta?.type === 'currency';
           if (monetary) {
             const resolved = mc.currency ?? meta?.defaultCurrency ?? context?.currency;
@@ -3566,6 +3594,7 @@ export class AnalyticsService implements IAnalyticsService {
       // [#21044] Judged on the AUGMENTED cube: a suffix-inferred measure and an
       // authored one are one population for the aggregate × field-type table.
       this.assertMeasureFieldTypes(query, augmented);
+      this.assertRecordCurrencyGrouped(query, augmented);
       // [#5669] The `where` gate resolves a filter member through dimensions AND
       // measures (that is what the strategies do for a filter member), so it is
       // handed the AUGMENTED cube — a caller filtering on a suffix-inferred
@@ -3582,6 +3611,7 @@ export class AnalyticsService implements IAnalyticsService {
       this.assertDimensionFields(query, cube, Object.keys(cube.dimensions));
       this.assertDimensionsGroupScalarColumns(query, cube);
       this.assertMeasureFieldTypes(query, cube);
+      this.assertRecordCurrencyGrouped(query, cube);
       this.assertWhereFields(query, cube, Object.keys(cube.dimensions));
     }
   }
@@ -3624,6 +3654,46 @@ export class AnalyticsService implements IAnalyticsService {
     );
   }
 
+  /**
+   * [ADR-0144 D6] Refuse a `sum` / `avg` / `min` / `max` measure over a
+   * `record`-mode amount whose query does not group by the amount's code field
+   * — `INVALID_FIELD` / 400, naming the member the caller wrote — before either
+   * strategy reads anything. The rule and the envelope are
+   * {@link assertRecordCurrencyAggregatesGrouped}'s
+   * (`cube-record-currency-door.ts`); this method supplies the answers only the
+   * service has: the measure column {@link declaredMeasureColumn} resolves
+   * (the #21044 door's resolver), each dimension's column by the same
+   * {@link declaredMemberEntry} lookup and hop resolver, and the code field off
+   * {@link AnalyticsServiceConfig.sourceFieldMeta}.
+   *
+   * Runs after the #21044 door, so a pair the field-type table refuses is
+   * answered as that first. Same stand-downs: no `sourceFieldMeta`, or a cube
+   * whose `sql` is not a bare object name.
+   */
+  private assertRecordCurrencyGrouped(query: AnalyticsQuery, cube: Cube): void {
+    const fieldMeta = this.sourceFieldMeta;
+    if (!fieldMeta) return;
+    const object = typeof cube.sql === 'string' ? cube.sql.trim() : '';
+    if (!object || !BARE_IDENTIFIER.test(object)) return;
+    assertRecordCurrencyAggregatesGrouped(
+      query,
+      cube.name,
+      (member) => declaredMeasureColumn(cube, member, object, this.hopReference),
+      (member) => {
+        const entry = declaredMemberEntry(cube, member, 'dimension');
+        const sql = (entry ? (typeof entry.sql === 'string' ? entry.sql : '') : member).trim();
+        if (BARE_IDENTIFIER.test(sql)) return { object, column: sql, path: sql };
+        if (!IDENTIFIER_PATH.test(sql)) return null;
+        return {
+          object: columnObjectOf(cube, object, sql, this.hopReference),
+          column: sql.slice(sql.lastIndexOf('.') + 1),
+          path: sql,
+        };
+      },
+      (o, field) => fieldMeta(o, field)?.currencyField,
+    );
+  }
+
   /**
    * [#20807] Refuse a GROUPED dimension whose column is a declared
    * structured-JSON field — `INVALID_FIELD` / 400, naming the member the caller
 
@@ -0,0 +1,112 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [ADR-0144 D6] The cube door's record-currency judgment: a `sum` / `avg` /
+ * `min` / `max` measure over a `currencyMode: 'record'` amount is refused
+ * `INVALID_FIELD` / 400 unless the same query groups by that amount's code
+ * field (`currencyConfig.currencyField`), ahead of strategy selection.
+ *
+ * ## The shape this closes
+ *
+ * A record-mode amount is a bare number (ADR-0104 D1) whose currency lives in a
+ * sibling code field, one per row. An aggregate that does not group by the code
+ * adds, averages or orders numbers in different currencies: the measurement
+ * round on #8345 (probe A) saw a USD row of 100 and an EUR row of 100 answer
+ * `200`, labelled with the tenant currency. Grouped by the code, every group
+ * holds one currency and the answer is right (probe C); the per-row label is
+ * the result column's `currencyField` (`AnalyticsResult.fields`,
+ * `@objectstack/spec/contracts`).
+ *
+ * ## Where it stands
+ *
+ * In `AnalyticsService.ensureCube`, on every path out of it, right after the
+ * #21044 measure × field-type door (`cube-measure-field-type-door.ts`): ahead
+ * of both strategies, for `query()` and `generateSql()` alike. A dataset
+ * selection reaches it through `DatasetExecutor`, so its primary grid, every
+ * `totals` grouping (the grand total `[]` included) and the `compareTo` pass
+ * are judged one by one: a grouping that drops the code is a sum across
+ * currencies like any other.
+ *
+ * ## What it judges
+ *
+ * - Every `measures` entry that resolves to a cube measure of type `sum`,
+ *   `avg`, `min` or `max` (ADR-0144 open item 10). `count` and
+ *   `count_distinct` read no amount and are not judged.
+ * - The measure's column, located on the object that declares it by the
+ *   caller's resolver (`declaredMeasureColumn`, the one the #21044 door reads).
+ * - "Grouped by the code" means a `dimensions` entry whose column is the code
+ *   field on that SAME object. A time dimension is no currency group, and a
+ *   `where` that happens to pin one code is not judged: the rule is the
+ *   grouping, so an answer's label never depends on what a filter selected.
+ *
+ * ## Not judged — "cannot answer, do not block"
+ *
+ * - A host that wires no `sourceFieldMeta`, or a cube whose `sql` is not a
+ *   bare object name (the caller stands down for both).
+ * - A member that resolves to no declared measure, a `sql` that is not a
+ *   column reference, or a column whose declaration names no `record` mode.
+ *
+ * ## The envelope
+ *
+ * `INVALID_FIELD` / 400 through `invalidMemberError` (ADR-0112), with the
+ * column and its object attached, as the #21044 door attaches them: a verdict
+ * about one member the request named. The words carry the prescription:
+ * group by the code field. A consolidated total over the stored home-currency
+ * amount is ADR-0144 D5's, which ships with the write-time projection.
+ */
+
+import type { AnalyticsQuery } from '@objectstack/spec/contracts';
+import type { MeasureColumn } from './cube-measure-field-type-door.js';
+import { invalidMemberError } from './dataset-refusal.js';
+
+/** The aggregates that read the amount itself (ADR-0144 open item 10). */
+const AMOUNT_AGGREGATES: ReadonlySet<string> = new Set(['sum', 'avg', 'min', 'max']);
+
+/**
+ * Refuse the first `measures` entry of `query` that aggregates a record-mode
+ * amount without grouping by its code field — `INVALID_FIELD` / 400. See the
+ * module header.
+ *
+ * @param measureOf - The cube measure a `measures` entry resolves to: its
+ *   `type`, and the column it aggregates (`null` when its `sql` is not a column
+ *   reference) — or `undefined` when it resolves to no declared measure.
+ * @param dimensionColumnOf - The column a `dimensions` entry groups by, located
+ *   the same way, or `null` when this door cannot pin one.
+ * @param recordCurrencyFieldOf - The `currencyConfig.currencyField` of a column
+ *   declared `currencyMode: 'record'`, or `undefined` for any other column.
+ */
+export function assertRecordCurrencyAggregatesGrouped(
+  query: AnalyticsQuery,
+  cubeName: string,
+  measureOf: (member: string) => { type: unknown; column: MeasureColumn | null } | undefined,
+  dimensionColumnOf: (member: string) => MeasureColumn | null,
+  recordCurrencyFieldOf: (object: string, field: string) => string | undefined,
+): void {
+  const measures = query.measures ?? [];
+  if (measures.length === 0) return;
+  let grouped: Array<MeasureColumn | null> | undefined;
+  for (const member of measures) {
+    const measure = measureOf(member);
+    if (!measure?.column || typeof measure.type !== 'string' || !AMOUNT_AGGREGATES.has(measure.type)) continue;
+    const target = measure.column;
+    const codeField = recordCurrencyFieldOf(target.object, target.column);
+    if (codeField === undefined) continue;
+    grouped ??= (query.dimensions ?? []).map(dimensionColumnOf);
+    if (grouped.some((d) => d?.object === target.object && d.column === codeField)) continue;
+
+    const codePath = target.path === target.column
+      ? codeField
+      : `${target.path.slice(0, target.path.lastIndexOf('.') + 1)}${codeField}`;
+    const err = invalidMemberError(
+      `Measure '${member}' on cube '${cubeName}' takes the ${measure.type} of field '${target.path}', `
+      + `a record-currency amount whose currency is each record's '${codeField}', but the query does not `
+      + `group by '${codePath}', so the query was NOT run. Add the dimension over '${codePath}' to the `
+      + `query, which answers one row per currency. Without the grouping the ${measure.type} would `
+      + 'combine amounts in different currencies into one number.',
+      { member, param: 'measures', cube: cubeName },
+    ) as Error & { field?: string; object?: string };
+    err.field = target.path;
+    err.object = target.object;
+    throw err;
+  }
+}
@@ -18,6 +18,7 @@ import {
 } from '@objectstack/spec/ui';
 import type { FilterCondition } from '@objectstack/spec/data';
 import { datasetInvalidError } from './dataset-refusal.js';
+import { assertMeasureCurrenciesCoherent, type DeclaredCurrency } from './measure-currency-coherence.js';
 import { TEMPORAL_SOURCE_FIELD_TYPES } from './measure-result-type.js';
 import type { DurationMeasureSpec } from './strategies/types.js';
 
@@ -194,6 +195,16 @@ export interface DatasetCompileOptions {
    * `declaredFieldType` (the type alone) until then.
    */
   declaredValueShape?: (objectName: string, field: string) => ValueShapeFieldDef | undefined;
+  /**
+   * [ADR-0144, M0-3] The declared CURRENCY of `field` on `objectName` — its
+   * type, its `fixed` code and its `record` code field — or `undefined` when
+   * nothing authoritative can answer. Supplied by the host from the same
+   * `AnalyticsServiceConfig.sourceFieldMeta` the result-column currency chain
+   * reads, so the compile-time guards of `measure-currency-coherence.ts` judge
+   * the currency the column would print. Absent → only an explicit measure
+   * `currency` is known, and the guards judge what that alone proves.
+   */
+  declaredCurrency?: (objectName: string, field: string) => DeclaredCurrency | undefined;
 }
 
 /** Map a dataset measure's aggregate to the Cube metric `type`. */
@@ -843,6 +854,11 @@ 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.
+  assertMeasureCurrenciesCoherent(dataset, options?.declaredCurrency);
+
   const cube: Cube = {
     name: dataset.name,
     // [#6761] The cube's own display title, same rule. `Cube.title` is optional