@@ -0,0 +1,13 @@
+---
+"@objectstack/spec": patch
+"@objectstack/lint": patch
+"@objectstack/service-analytics": patch
+---
+
+fix(lint, service-analytics): a total over a formula field names the stored-number remedy, not a count
+
+Clause-②: no
+
+- **What changed.** A dataset or cube measure taking `sum`, `avg`, `min` or `max` over a `formula` field is still refused (`measure-aggregate-field-type-refused` in `os validate`, `400 DATASET_INVALID` at the dataset compile). The prescription changed. It used to name `count` / `count_distinct` as the way out, and a count read as a total is a plausible wrong number (3 records shown as "total leave days" where the true total is 10). It now reads: "The field is computed on read and stores no value: store the value as a number field (kept by a hook) and aggregate that. `count` / `count_distinct` answer a different question: how many records."
+- **One source.** The sentence lives in `@objectstack/spec/data` as `VIRTUAL_FIELD_AGGREGATE_REMEDY`, returned by `virtualFieldAggregateRemedy(aggregate, fieldType)` for a refused value-reading aggregate over a virtual type (`SEARCH_VIRTUAL_TYPES`, which is `formula`). The function returns `undefined` for every other pair. The lint hint, its `os explain measure-aggregate-field-type-refused` entry and the dataset compile leg all print this one sentence.
+- **What stays the same.** Nothing is newly accepted or refused. Every other refused pair keeps its own hint, including `count_distinct` over a JSON-stored or `multiple: true` field. The analytics door's cube-query refusal (`400 INVALID_FIELD`) and the engine's `aggregate` door keep their own wording.
@@ -1890,8 +1890,15 @@ const MEASURE_AGGREGATE_FIELD_TYPE_REFUSED_EXPLANATION: RuleExplanation = {
       'toggle; `min` and `max`: number, currency, percent, rating, slider, progress, summary, date, ' +
       'datetime, time, boolean, toggle.',
     'So the fix is a field of an accepted type, or an aggregate the field\'s declaration accepts. A ' +
-      'quantity that must be added up or averaged has to be STORED as a numeric field (a computed ' +
-      'column) and aggregated as one.',
+      'quantity that must be added up or averaged has to be STORED as a numeric field and aggregated as ' +
+      'one.',
+    // Held equal to `VIRTUAL_FIELD_AGGREGATE_REMEDY` (`@objectstack/spec/data`) — the `fix:` line, and
+    // the compile leg's remedy, for this pair — by `validate-dataset-measure-aggregates.test.ts`.
+    'A `formula` field stores no value, whatever its `returnType` says, so `sum`, `avg`, `min` and `max` ' +
+      'over one have no column to read, and a count substituted for the total is a plausible wrong ' +
+      'number. Its fix line reads: The field is computed on read and stores no value: store the value as ' +
+      'a number field (kept by a hook) and aggregate that. `count` / `count_distinct` answer a different ' +
+      'question: how many records.',
     JSON_STORED_COLUMN,
     'The per-type row cannot see `multiple: true`, so `count_distinct` over a multi-capable field ' +
       'flagged that way is refused by the declaration: the value is a list stored as JSON, and ' +
 
@@ -22,6 +22,7 @@ import {
   MULTI_OPTION_TYPES,
   NUMERIC_VALUE_TYPES,
   STRUCTURED_JSON_TYPES,
+  VIRTUAL_FIELD_AGGREGATE_REMEDY,
   isAggregateCompatibleWithFieldType,
   isMultiValueField,
   type Field,
@@ -432,6 +433,54 @@ const flaggedStackWith = (aggregate: string, fieldType: string): Record<string,
     fields: { name: { type: 'text' }, measured: { type: fieldType, multiple: true } },
   });
 
+// [#24426] A total over a VIRTUAL field. A `formula` stores no value, so the
+// way to its total is to store the value as a number field and aggregate that;
+// the hint used to name `count` / `count_distinct` as the way out instead,
+// which turns "total leave days" into a record count. The sentence is the
+// spec's, the one the compile leg prints too.
+describe('measure-aggregate-field-type-refused — a total over a formula names the stored-number remedy', () => {
+  it('sum over a formula field: the hint is the spec\'s stored-number remedy, the count only another question', () => {
+    const found = findings(stackWith('sum', 'formula'));
+    expect(found).toHaveLength(1);
+    const [issue] = found;
+    expect(issue.rule).toBe(RULE);
+    expect(issue.severity).toBe('error');
+    expect(issue.path).toBe('datasets[0].measures[0].aggregate');
+    expect(issue.hint).toBe(VIRTUAL_FIELD_AGGREGATE_REMEDY);
+    expect(issue.hint).toContain('store the value as a number field');
+    expect(issue.hint).toContain('answer a different question: how many records');
+    // The remedy comes first, and no count is offered as the way to the total.
+    expect(issue.hint.indexOf('number field')).toBeLessThan(issue.hint.indexOf('`count`'));
+    expect(issue.hint).not.toContain('accepts: count');
+    expect(issue.hint).not.toContain('Either point');
+  });
+
+  it('avg, min and max over a formula read the same sentence', () => {
+    for (const aggregate of ['avg', 'min', 'max']) {
+      const [issue] = findings(stackWith(aggregate, 'formula'));
+      expect(issue?.hint, aggregate).toBe(VIRTUAL_FIELD_AGGREGATE_REMEDY);
+    }
+  });
+
+  it('`os explain` holds the same sentence verbatim', () => {
+    expect(explanationOf(RULE)).toContain(VIRTUAL_FIELD_AGGREGATE_REMEDY);
+  });
+
+  it('the controls: a stored class and the count_distinct × JSON-list case keep their own hints', () => {
+    const [text] = findings(stackWith('sum', 'text'));
+    expect(text?.hint).toContain('type accepts: count, count_distinct.');
+    expect(text?.hint).not.toBe(VIRTUAL_FIELD_AGGREGATE_REMEDY);
+    const [list] = findings(flaggedStackWith('count_distinct', 'select'));
+    expect(list?.hint).toContain('declaration accepts: count.');
+    expect(list?.hint).not.toContain('number field');
+    const [json] = findings(stackWith('count_distinct', 'json'));
+    expect(json?.hint).toContain('type accepts: count.');
+    expect(json?.hint).not.toContain('number field');
+    // count over a formula is accepted — nothing to prescribe.
+    expect(findings(stackWith('count', 'formula'))).toEqual([]);
+  });
+});
+
 describe('measure-aggregate-field-type-refused — reads the declaration, not the type alone', () => {
   // ⭐ The addendum's pin and its control, one pair.
   it('refuses count_distinct over a select declared multiple: true, and accepts it over a single select', () => {
@@ -1271,7 +1320,8 @@ describe('[#22161] one-line fixes — the two ids', () => {
     const facts: Record<string, readonly string[]> = {
       [MEASURE_AGGREGATE_FIELD_TYPE_REFUSED]: [
         '`count` accepts every type, because it reads no value',
-        'STORED as a numeric field (a computed column)',
+        'STORED as a numeric field and aggregated as one',
+        VIRTUAL_FIELD_AGGREGATE_REMEDY,
         "a dataset's by its compile (`400 DATASET_INVALID`)",
         "a cube's by the analytics door when a query names the measure (`400 INVALID_FIELD`)",
       ],
 
@@ -199,6 +199,7 @@ import {
   STRUCTURED_JSON_TYPES,
   isAggregateCompatibleWithFieldType,
   isMultiValueField,
+  virtualFieldAggregateRemedy,
   type ValueShapeFieldDef,
 } from '@objectstack/spec/data';
 
@@ -417,6 +418,12 @@ function jsonStoredDimensionFinding(
  * further, the stored-numeric route for a sum or an average, and which door
  * refuses the same pair later (a dataset's compile, a cube's query) are the
  * same explanation's.
+ *
+ * [#24426] Except over a VIRTUAL field (`formula`): there the remedy line is
+ * the spec's `virtualFieldAggregateRemedy`, the sentence the compile leg prints
+ * too — store the value as a number field and aggregate that — because naming
+ * `count` as the way out steers a total to a plausible wrong number (a record
+ * count read as a sum). The count stays named, as a different question.
  */
 function refusedMeasureFinding(
   site: MemberSite,
@@ -441,6 +448,7 @@ function refusedMeasureFinding(
       : `${pair(`\`${fieldType}\``)} is refused by the aggregate × field-type table: the number would depend ` +
         'on the SQL dialect',
     hint:
+      virtualFieldAggregateRemedy(aggregate, fieldType) ??
       `Either point "${aggregate}" at a field of an accepted type, or aggregate ` +
       `"${site.column}" with one its ${declaredAs(shape)} ${shape.multiple === true ? 'declaration' : 'type'} accepts: ` +
       `${aggregatesAccepting(shape).join(', ')}.`,
 
@@ -57,6 +57,7 @@
 import { describe, it, expect } from 'vitest';
 import {
   AGGREGATE_FIELD_TYPE_COMPATIBILITY,
+  VIRTUAL_FIELD_AGGREGATE_REMEDY,
   isAggregateCompatibleWithFieldType,
   FieldType,
 } from '@objectstack/spec/data';
@@ -242,6 +243,28 @@ describe('#16099 — a DERIVING aggregate over a field type that cannot carry it
     expect(err.message).not.toContain('real instant');
   });
 
+  // [#24426] A total over a VIRTUAL field (`formula`) names the spec's remedy
+  // first — store the value as a number field and aggregate that — and a count
+  // only as a different question. The sentence is the spec's, the one the lint
+  // leg prints too, so the two doors cannot prescribe two different ways out.
+  it('a total over a formula prints the stored-number remedy — the spec\'s sentence, not the count or sort one', async () => {
+    for (const aggregate of ['sum', 'avg', 'min', 'max'] as const) {
+      const { go, sqls } = run(aggregate, 'margin', [{ status: 'open', probe_measure: 1 }]);
+      const err = await refusalOf(go);
+      expect(err.code, aggregate).toBe('DATASET_INVALID');
+      expect(err.status, aggregate).toBe(400);
+      expect(err.message, aggregate).toContain(VIRTUAL_FIELD_AGGREGATE_REMEDY);
+      expect(err.message, aggregate).toContain('store the value as a number field');
+      expect(err.message, aggregate).not.toContain('For a non-numeric field');
+      expect(err.message, aggregate).not.toContain('SORT on the record list');
+      expect(sqls.length, aggregate).toBe(0);
+    }
+    // Control: a refused pair over a STORED non-numeric class keeps its own words.
+    const text = await refusalOf(run('sum', 'note').go);
+    expect(text.message).toContain('For a non-numeric field');
+    expect(text.message).not.toContain(VIRTUAL_FIELD_AGGREGATE_REMEDY);
+  });
+
   it('a TEMPORAL refusal keeps #16778\'s own remedy sentence — continuity control', async () => {
     const err = await refusalOf(run('avg', 'submitted_at').go);
     expect(err.code).toBe('DATASET_INVALID');
 
@@ -7,6 +7,7 @@ import {
   AggregationFunction,
   isAggregateCompatibleWithFieldType,
   isMultiValueField,
+  virtualFieldAggregateRemedy,
 } from '@objectstack/spec/data';
 import type { Dataset, DatasetMeasure, DatasetDimension } from '@objectstack/spec/ui';
 import { resolveI18nLabel } from '@objectstack/spec/ui';
@@ -271,9 +272,15 @@ const DIVERGENCE_BY_AGGREGATE = (aggregate: string, fieldType: string, column =
  * counts rows, or counts distinct a scalar field holding the part they meant.
  * The other two non-temporal sentences no longer say `count_distinct` accepts
  * every type: since #20808 it accepts every type but the JSON-stored ones.
+ * [#24426] A VIRTUAL field (`formula`) is answered first, and not here: its
+ * sentence is the spec's `virtualFieldAggregateRemedy`, the one the lint leg
+ * prints too — store the value as a number field and aggregate that, with a
+ * count named only as a different question. A count is no way to a total.
  */
-const REMEDY_BY_SOURCE_CLASS = (fieldType: string, aggregate: string): string =>
-  TEMPORAL_SOURCE_FIELD_TYPES.has(fieldType)
+const REMEDY_BY_SOURCE_CLASS = (fieldType: string, aggregate: string): string => {
+  const virtual = virtualFieldAggregateRemedy(aggregate, fieldType);
+  if (virtual !== undefined) return virtual;
+  return TEMPORAL_SOURCE_FIELD_TYPES.has(fieldType)
     ? 'For a temporal field, `min`/`max` return a real instant; a DURATION has to be '
       + 'stored as a number (a computed "days open" field) and aggregated as one.'
     : aggregate === 'count_distinct'
@@ -288,6 +295,7 @@ const REMEDY_BY_SOURCE_CLASS = (fieldType: string, aggregate: string): string =>
       : 'For a non-numeric field, `count` accepts every type because it reads no value, and '
         + '`count_distinct` every type but the JSON-stored ones; a quantity that should be '
         + 'added up has to be stored as a numeric field and aggregated as one.';
+};
 
 /**
  * [#16737 / #16099 / #17560] Refuse a measure whose AGGREGATE cannot meaningfully
 
@@ -804,6 +804,7 @@
     "VALUE_ROUNDTRIP_COLLISION_PAIRS (const)",
     "VALUE_ROUNDTRIP_FIELDS (const)",
     "VALUE_ROUNDTRIP_ROWS (const)",
+    "VIRTUAL_FIELD_AGGREGATE_REMEDY (const)",
     "ValidationAdvisoryEvent (type)",
     "ValidationAdvisoryEventSchema (const)",
     "ValidationRule (type)",
@@ -994,6 +995,7 @@
     "utcInstantMs (function)",
     "validateDriverConfig (function)",
     "valueRoundTripDivergence (function)",
-    "valueSchemaFor (function)"
+    "valueSchemaFor (function)",
+    "virtualFieldAggregateRemedy (function)"
   ]
 }
@@ -790,6 +790,7 @@
     "VALUE_ROUNDTRIP_COLLISION_PAIRS": "src/data/value-roundtrip-conformance.ts#VALUE_ROUNDTRIP_COLLISION_PAIRS (const)",
     "VALUE_ROUNDTRIP_FIELDS": "src/data/value-roundtrip-conformance.ts#VALUE_ROUNDTRIP_FIELDS (const)",
     "VALUE_ROUNDTRIP_ROWS": "src/data/value-roundtrip-conformance.ts#VALUE_ROUNDTRIP_ROWS (const)",
+    "VIRTUAL_FIELD_AGGREGATE_REMEDY": "src/data/aggregate-field-type-compatibility.ts#VIRTUAL_FIELD_AGGREGATE_REMEDY (const)",
     "ValidationAdvisoryEvent": "src/data/data-engine.zod.ts#ValidationAdvisoryEvent (type)",
     "ValidationAdvisoryEventSchema": "src/data/data-engine.zod.ts#ValidationAdvisoryEventSchema (const)",
     "ValidationRule": "src/data/validation.zod.ts#ValidationRule (type)",
@@ -980,6 +981,7 @@
     "utcInstantMs": "src/data/calendar-day.ts#utcInstantMs (function)",
     "validateDriverConfig": "src/data/driver/config-registry.zod.ts#validateDriverConfig (function)",
     "valueRoundTripDivergence": "src/data/value-roundtrip-conformance.ts#valueRoundTripDivergence (function)",
-    "valueSchemaFor": "src/data/field-value.zod.ts#valueSchemaFor (function)"
+    "valueSchemaFor": "src/data/field-value.zod.ts#valueSchemaFor (function)",
+    "virtualFieldAggregateRemedy": "src/data/aggregate-field-type-compatibility.ts#virtualFieldAggregateRemedy (function)"
   }
 }
@@ -31,9 +31,12 @@ import {
 } from './field-value.zod';
 import { isIncoherentAggregate } from './aggregation-policy';
 import { AGGREGATION_CASES } from './aggregation-conformance';
+import { SEARCH_VIRTUAL_TYPES } from './search-fields';
 import {
   AGGREGATE_FIELD_TYPE_COMPATIBILITY,
+  VIRTUAL_FIELD_AGGREGATE_REMEDY,
   isAggregateCompatibleWithFieldType,
+  virtualFieldAggregateRemedy,
 } from './aggregate-field-type-compatibility';
 
 const sorted = (xs: Iterable<string>) => [...xs].sort();
@@ -244,3 +247,54 @@ describe('isAggregateCompatibleWithFieldType — the pairs the card is about', (
     }
   });
 });
+
+describe('virtualFieldAggregateRemedy — the one prescription for a total over a virtual field', () => {
+  it('names the stored-number remedy for sum / avg / min / max over a formula, and a count only as another question', () => {
+    for (const aggregate of ['sum', 'avg', 'min', 'max']) {
+      // Not vacuous: the table refuses every one of these pairs.
+      expect(isAggregateCompatibleWithFieldType(aggregate, 'formula'), aggregate).toBe(false);
+      expect(virtualFieldAggregateRemedy(aggregate, 'formula'), aggregate).toBe(VIRTUAL_FIELD_AGGREGATE_REMEDY);
+    }
+    expect(VIRTUAL_FIELD_AGGREGATE_REMEDY).toContain('store the value as a number field');
+    expect(VIRTUAL_FIELD_AGGREGATE_REMEDY).toContain('and aggregate that');
+    expect(VIRTUAL_FIELD_AGGREGATE_REMEDY).toContain('answer a different question: how many records');
+    // The remedy comes FIRST: the count is named only after it.
+    expect(VIRTUAL_FIELD_AGGREGATE_REMEDY.indexOf('number field'))
+      .toBeLessThan(VIRTUAL_FIELD_AGGREGATE_REMEDY.indexOf('`count`'));
+  });
+
+  it('is one line of at most 200 characters — the lint prints it whole as its `fix:` line', () => {
+    expect(VIRTUAL_FIELD_AGGREGATE_REMEDY).not.toContain('\n');
+    expect(VIRTUAL_FIELD_AGGREGATE_REMEDY.length).toBeLessThanOrEqual(200);
+  });
+
+  it('answers undefined for every other pair — each keeps its own class\'s prescription', () => {
+    // An accepted pair over the virtual class: no refusal, no prescription.
+    expect(isAggregateCompatibleWithFieldType('count', 'formula')).toBe(true);
+    expect(virtualFieldAggregateRemedy('count', 'formula')).toBeUndefined();
+    expect(virtualFieldAggregateRemedy('count_distinct', 'formula')).toBeUndefined();
+    // A refused pair over a STORED class keeps its own words.
+    for (const fieldType of ['text', 'autonumber', 'json', 'datetime', 'percent']) {
+      for (const aggregate of ['sum', 'avg', 'min', 'max', 'count_distinct']) {
+        expect(virtualFieldAggregateRemedy(aggregate, fieldType), `${aggregate} × ${fieldType}`).toBeUndefined();
+      }
+    }
+    // Fail-closed on shape, like the predicate.
+    const loose = virtualFieldAggregateRemedy as unknown as (a: unknown, f: unknown) => string | undefined;
+    expect(loose(['sum'], 'formula')).toBeUndefined();
+    expect(loose('sum', ['formula'])).toBeUndefined();
+    expect(loose(undefined, 'formula')).toBeUndefined();
+  });
+
+  it('the virtual class is the drivers\' storage rule — every type in it is refused for all four value-reading rows', () => {
+    // The prescription keys on `SEARCH_VIRTUAL_TYPES`; a type joining that set
+    // must be one this table already refuses to add up, or the remedy would
+    // speak for an accepted pair.
+    expect([...SEARCH_VIRTUAL_TYPES]).toContain('formula');
+    for (const t of SEARCH_VIRTUAL_TYPES) {
+      for (const aggregate of ['sum', 'avg', 'min', 'max']) {
+        expect(AGGREGATE_FIELD_TYPE_COMPATIBILITY[aggregate as 'sum'] as readonly string[]).not.toContain(t);
+      }
+    }
+  });
+});