@@ -0,0 +1,12 @@
+---
+'@objectstack/plugin-audit': patch
+---
+
+fix(plugin-audit): an activity entry for an update that moves no `trackHistory` field names the fields that changed
+
+Clause-②: no
+Metadata-protocol: none
+
+The record Discussion feed wrote `Updated <object> "<label>"` for every update that fired no milestone and changed no `trackHistory` field, so a record a roll-up, flow or seed updates repeatedly showed a run of identical entries with nothing to tell them apart. That entry now names the changed fields by label, in declaration order: `Updated Campaign "CPG-0001": Number Sent, Responses, and Leads`. Values are still rendered only for `trackHistory` fields; an untracked field's value never reaches the text.
+
+At most five fields are named and the rest counted (`…, and 3 more`), and fewer are named when the text would exceed the `maxLength` declared on `sys_activity.summary`. Each named or counted field is recorded as a source of the summary, so a reader not served one of those fields is served the entry without its summary, as for a tracked-change entry. Two message keys are added to the plugin's en, zh-CN, ja-JP and es-ES bundles, `messages.activityUpdatedFields` and `messages.activityMoreFields`. A locale bundle that defines `messages.activityUpdated` but not `messages.activityUpdatedFields` keeps its field-less sentence.
@@ -562,7 +562,7 @@ describe('audit writers — declarative trackHistory activity (ADR-0052 §5b)',
     expect(activity?.row.summary).toBe('Stage: Proposal → Closed Won');
   });
 
-  it('falls back to the generic summary when only untracked fields change', async () => {
+  it('falls back to the generic summary, naming the untracked field that changed', async () => {
     const { engine, fire, created } = makeEngine(SCHEMA);
     installAuditWriters(engine as any, 'test.audit');
 
@@ -575,7 +575,129 @@ describe('audit writers — declarative trackHistory activity (ADR-0052 §5b)',
     });
 
     const activity = created.find((c) => c.object === 'sys_activity');
-    expect(activity?.row.summary).toBe('Updated crm_opportunity "Acme Renewal"');
+    // The label, never the value: `amount` is not `trackHistory`'d.
+    expect(activity?.row.summary).toBe('Updated crm_opportunity "Acme Renewal": Amount');
+  });
+});
+
+describe('audit writers — the generic update summary names the changed fields (#25787)', () => {
+  // A campaign whose roll-up counters a hook bumps once per enrolled member —
+  // plain number fields, none `trackHistory`'d (the measured HotCRM shape).
+  const CAMPAIGN_FIELDS: Record<string, any> = {
+    id: { type: 'text' },
+    name: { type: 'text', label: 'Name' },
+    num_sent: { type: 'number', label: 'Number Sent' },
+    num_responses: { type: 'number', label: 'Responses' },
+    num_leads: { type: 'number', label: 'Leads' },
+    budget_code: { type: 'text', label: 'Budget Code' },
+    api_token: { type: 'secret', label: 'API Token' },
+  };
+  const schemaWith = (fields: Record<string, any>, summary: Record<string, any> = { type: 'text' }) => ({
+    sys_audit_log: SINGLE_TENANT.sys_audit_log,
+    sys_activity: {
+      ...Object.fromEntries(SINGLE_TENANT.sys_activity.map((f) => [f, { type: 'text' }])),
+      summary,
+    },
+    campaign: fields,
+  });
+
+  async function updateCampaign(
+    schema: Record<string, any>,
+    previous: Record<string, any>,
+    result: Record<string, any>,
+  ) {
+    const { engine, fire, created } = makeEngine(schema, { campaign: { label: 'Campaign' } });
+    installAuditWriters(engine as any, 'test.audit');
+    await fire('afterUpdate', {
+      object: 'campaign',
+      input: { id: 'cpg-1' },
+      result: { id: 'cpg-1', name: 'CPG-0001', ...result },
+      previous: { id: 'cpg-1', name: 'CPG-0001', ...previous },
+      session: {},
+    });
+    const activity = created.find((c) => c.object === 'sys_activity');
+    expect(activity).toBeDefined();
+    return { summary: activity!.row.summary as string, metadata: JSON.parse(activity!.row.metadata) };
+  }
+
+  it('names every changed field, in declaration order, as a list', async () => {
+    const { summary } = await updateCampaign(
+      schemaWith(CAMPAIGN_FIELDS),
+      { num_leads: 3, num_responses: 1, num_sent: 12 },
+      { num_leads: 4, num_responses: 2, num_sent: 13 },
+    );
+    expect(summary).toBe('Updated Campaign "CPG-0001": Number Sent, Responses, and Leads');
+  });
+
+  it('never carries a value: neither an untracked one nor a credential', async () => {
+    const { summary } = await updateCampaign(
+      schemaWith(CAMPAIGN_FIELDS),
+      { budget_code: 'BC-OLD-7731', api_token: 'tok-before-5512' },
+      { budget_code: 'BC-NEW-9924', api_token: 'tok-after-8843' },
+    );
+    expect(summary).toBe('Updated Campaign "CPG-0001": Budget Code and API Token');
+    for (const value of ['BC-OLD-7731', 'BC-NEW-9924', 'tok-before-5512', 'tok-after-8843']) {
+      expect(summary).not.toContain(value);
+    }
+  });
+
+  it('declares each named field as a summary source, so the read-side redaction drops the text for a reader not served one', async () => {
+    const { metadata } = await updateCampaign(
+      schemaWith(CAMPAIGN_FIELDS),
+      { num_sent: 12, budget_code: 'A' },
+      { num_sent: 13, budget_code: 'B' },
+    );
+    expect(metadata.text_sources.summary).toEqual(['name', 'num_sent', 'budget_code']);
+    expect(metadata.text_sources.record_label).toEqual(['name']);
+  });
+
+  it('names at most five fields and counts the rest, and declares the counted ones too', async () => {
+    const fields: Record<string, any> = { id: { type: 'text' }, name: { type: 'text', label: 'Name' } };
+    const previous: Record<string, any> = {};
+    const result: Record<string, any> = {};
+    for (let i = 1; i <= 8; i += 1) {
+      fields[`f${i}`] = { type: 'number', label: `Field ${i}` };
+      previous[`f${i}`] = 0;
+      result[`f${i}`] = 1;
+    }
+    const { summary, metadata } = await updateCampaign(schemaWith(fields), previous, result);
+    expect(summary).toBe(
+      'Updated Campaign "CPG-0001": Field 1, Field 2, Field 3, Field 4, Field 5, and 3 more',
+    );
+    expect(metadata.text_sources.summary).toEqual(['name', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8']);
+  });
+
+  it('keeps a wide update of long labels inside the declared sys_activity.summary bound (500)', async () => {
+    const fields: Record<string, any> = { id: { type: 'text' }, name: { type: 'text', label: 'Name' } };
+    const previous: Record<string, any> = {};
+    const result: Record<string, any> = {};
+    for (let i = 1; i <= 40; i += 1) {
+      fields[`f${i}`] = { type: 'number', label: `A Very Long Field Label Number ${i} `.repeat(4).trim() };
+      previous[`f${i}`] = 0;
+      result[`f${i}`] = 1;
+    }
+    const { summary } = await updateCampaign(
+      schemaWith(fields, { type: 'text', maxLength: 500 }),
+      previous,
+      result,
+    );
+    expect(summary.length).toBeLessThanOrEqual(500);
+    // Fewer than five names fit, and the rest is still counted, not dropped.
+    expect(summary).toMatch(/^Updated Campaign "CPG-0001": A Very Long Field Label Number 1 /);
+    expect(summary).toMatch(/, and 3[6-9] more$/);
+  });
+
+  it('falls back to the field-less frame when not even one name fits the bound', async () => {
+    const { summary, metadata } = await updateCampaign(
+      schemaWith({ ...CAMPAIGN_FIELDS, num_sent: { type: 'number', label: 'N'.repeat(60) } }, {
+        type: 'text',
+        maxLength: 40,
+      }),
+      { num_sent: 1 },
+      { num_sent: 2 },
+    );
+    expect(summary).toBe('Updated Campaign "CPG-0001"');
+    expect(metadata.text_sources.summary).toEqual(['name']);
   });
 });
 
@@ -1047,7 +1169,42 @@ describe('audit writers — localized activity summaries (framework#3039)', () =
       result: { id: 'q-1', name: 'OC-00001', status: 'active' },
     });
     const activity = created.find((c) => c.object === 'sys_activity');
-    expect(activity!.row.summary).toBe('更新了 人员资质 "OC-00001"');
+    // [#25787] `status` is undeclared here, so it is named by its key; the
+    // list and its frame are both the zh-CN bundle's.
+    expect(activity!.row.summary).toBe('更新了 人员资质 "OC-00001"：status');
+  });
+
+  it('keeps a locale\'s field-less frame when its bundle has no named-field frame', async () => {
+    // An app-shipped locale that predates `activityUpdatedFields` gets its own
+    // localized sentence, never an English one with its field names.
+    const i18n = createMemoryI18n();
+    i18n.loadTranslations('fr-FR', {
+      objects: { person_qualification: { label: 'Qualification' } },
+      messages: { activityUpdated: 'A mis à jour {{object}} « {{label}} »' },
+    });
+    const { fire, created } = setup('fr-FR', i18n);
+    await fire('afterUpdate', {
+      ...insertCtx(),
+      previous: { id: 'q-1', name: 'OC-00001', status: 'draft' },
+      result: { id: 'q-1', name: 'OC-00001', status: 'active' },
+    });
+    const activity = created.find((c) => c.object === 'sys_activity');
+    expect(activity!.row.summary).toBe('A mis à jour Qualification « OC-00001 »');
+  });
+
+  it('localizes the named-field list and its "more" item (zh-CN)', async () => {
+    const fields: Record<string, any> = { id: { type: 'text' }, name: { type: 'text' } };
+    const previous: Record<string, any> = { id: 'q-1', name: 'OC-00001' };
+    const result: Record<string, any> = { id: 'q-1', name: 'OC-00001' };
+    for (let i = 1; i <= 7; i += 1) {
+      fields[`f${i}`] = { type: 'number', label: `F${i}` };
+      previous[`f${i}`] = 0;
+      result[`f${i}`] = 1;
+    }
+    const { fire, created } = setup('zh-CN', makeI18n(), {}, { ...SINGLE_TENANT, person_qualification: fields });
+    await fire('afterUpdate', { ...insertCtx(), previous, result });
+    const activity = created.find((c) => c.object === 'sys_activity');
+    expect(activity!.row.summary).toBe('更新了 人员资质 "OC-00001"：F1、F2、F3、F4、F5和另外 2 个字段');
   });
 
   it('falls back to the object def label, then English, when a translation misses', async () => {
 
@@ -760,7 +760,8 @@ function planTrackedLookupReads(
  * summary ("Stage: Proposal → Closed Won"; multiple changes joined by "; "),
  * using the field label, select option labels and referenced record titles.
  * Returns null when no tracked field changed, so the caller falls back to the
- * generic "Updated <object>".
+ * generic "Updated <object>", which names the changed fields
+ * ({@link renderChangedFieldsSummary}).
  *
  * [#7230] `translate` is the SAME locale-bound translator the three sibling
  * summary branches already resolve through (`messages.activityCreated` /
@@ -798,9 +799,7 @@ function renderTrackedChangeSummary(
   for (const key of Object.keys(newVals)) {
     const field = fields[key];
     if (!field || field.trackHistory !== true) continue;
-    const label =
-      translate(`objects.${objectName}.fields.${key}.label`) ??
-      (typeof field.label === 'string' && field.label.length > 0 ? field.label : key);
+    const label = fieldLabelForSummary(objectName, key, field, translate);
     const reference = referenceTargetForSummary(field);
     const titlesFor = reference ? lookupTitles?.get(reference) : undefined;
     // Only a field that DECLARES options can consume this, so the ordinary
@@ -822,6 +821,116 @@ function renderTrackedChangeSummary(
   return parts.length > 0 ? { text: parts.join('; '), fields: rendered } : null;
 }
 
+/**
+ * A field's label inside an activity summary: the locale bundle's
+ * (`objects.<object>.fields.<field>.label`), then the authored def label, then
+ * the machine key. One answer for both branches that name a field.
+ */
+function fieldLabelForSummary(
+  objectName: string,
+  key: string,
+  field: any,
+  translate: (key: string, params?: Record<string, unknown>) => string | undefined,
+): string {
+  return (
+    translate(`objects.${objectName}.fields.${key}.label`) ??
+    (typeof field?.label === 'string' && field.label.length > 0 ? field.label : key)
+  );
+}
+
+/**
+ * [#25787] How many changed fields the generic update summary names before it
+ * counts the rest ("… and 3 more").
+ */
+const MAX_NAMED_CHANGED_FIELDS = 5;
+
+/**
+ * [#25787] The generic update summary, naming WHICH fields changed — never
+ * their values. Reached when no milestone fired and no `trackHistory` field
+ * changed: before this, the row said only `Updated <object> "<label>"`, so a
+ * record a rollup or flow bumps repeatedly showed a wall of identical entries
+ * nobody could read. `trackHistory` still governs what it always did — whether
+ * a field's old → new VALUES are rendered (ADR-0052 §5b.1); an untracked
+ * field's value never reaches the text, only its label does.
+ *
+ * Names fields in declaration order (keys the definition does not carry come
+ * after, by key), at most {@link MAX_NAMED_CHANGED_FIELDS}, then counts the
+ * rest. When `sys_activity.summary` declares `maxLength` (the SQL driver sizes
+ * the column `varchar(n)` from it, so an over-long text fails the whole
+ * activity insert), fewer fields are named until the text fits. Returns null
+ * when nothing changed, when not even one name fits, or when the locale has a
+ * field-less frame but no named-field one, and the caller writes the
+ * field-less frame.
+ *
+ * Returns the fields it COUNTED as well as named in `fields`: the read side
+ * drops a summary composed from a field the reader is not served
+ * (`activity-field-redaction.ts`), and "and 3 more" says three fields changed.
+ */
+function renderChangedFieldsSummary(
+  objectName: string,
+  fields: Record<string, any> | undefined | null,
+  newVals: Record<string, any> | null,
+  translate: (key: string, params?: Record<string, unknown>) => string | undefined,
+  locale: string | undefined,
+  frame: { object: string; label: string },
+  maxLength: number | undefined,
+): { text: string; fields: string[] } | null {
+  if (!newVals) return null;
+  const changed = new Set(Object.keys(newVals));
+  if (changed.size === 0) return null;
+  const ordered = [
+    ...Object.keys(fields ?? {}).filter((key) => changed.has(key)),
+    ...[...changed].filter((key) => !fields || !(key in fields)).sort(),
+  ];
+  const labels = ordered.map((key) => fieldLabelForSummary(objectName, key, fields?.[key], translate));
+  // The list joins in the locale whose frame is used, so an English fallback
+  // frame never carries a zh-CN "、" list. A locale whose bundle answers only
+  // the field-less `activityUpdated` (an app's own locale, written before this
+  // key existed) keeps that localized frame rather than an English one.
+  const localized = translate('messages.activityUpdatedFields', { ...frame, fields: '' }) !== undefined;
+  if (!localized && translate('messages.activityUpdated', frame) !== undefined) return null;
+  const joinList = listJoinerFor(localized ? locale : undefined);
+  const compose = (shown: number): string => {
+    const items = labels.slice(0, shown);
+    const rest = labels.length - shown;
+    if (rest > 0) {
+      items.push(translate('messages.activityMoreFields', { count: rest }) ?? `${rest} more`);
+    }
+    const list = joinList(items);
+    return (
+      translate('messages.activityUpdatedFields', { ...frame, fields: list }) ??
+      `Updated ${frame.object} "${frame.label}": ${list}`
+    );
+  };
+  for (let shown = Math.min(MAX_NAMED_CHANGED_FIELDS, labels.length); shown >= 1; shown -= 1) {
+    const text = compose(shown);
+    if (maxLength === undefined || text.length <= maxLength) return { text, fields: ordered };
+  }
+  return null;
+}
+
+/** A locale's conjunction list ("A, B, and C" / "A、B和C"); `", "` where `Intl` cannot answer. */
+function listJoinerFor(locale: string | undefined): (items: string[]) => string {
+  // `Intl.ListFormat` is ES2021; this package compiles against the ES2020 lib,
+  // so the constructor is probed rather than assumed (as `plugin-auth`'s
+  // invitation role label does).
+  const ListFormat = (Intl as unknown as { ListFormat?: IntlListFormatConstructor }).ListFormat;
+  try {
+    if (ListFormat) {
+      const format = new ListFormat(locale ?? 'en', { type: 'conjunction' });
+      return (items) => format.format(items);
+    }
+  } catch {
+    // A tag `Intl` refuses (a tenant's own locale spelling) still gets a list.
+  }
+  return (items) => items.join(', ');
+}
+
+type IntlListFormatConstructor = new (
+  locale: string,
+  options: { type: 'conjunction' },
+) => { format(list: readonly string[]): string };
+
 /**
  * [#7290] The `{token}` pattern of an `activityMilestones` summary template.
  *
@@ -1439,6 +1548,13 @@ export function installAuditWriters(
     return fields && typeof fields === 'object' && !Array.isArray(fields) ? fields : null;
   };
 
+  // [#25787] The bound the registered `sys_activity.summary` declares, read
+  // from the definition like every other gate here; `undefined` = unbounded.
+  const activitySummaryMaxLength = (): number | undefined => {
+    const maxLength = getFieldDefs('sys_activity')?.summary?.maxLength;
+    return typeof maxLength === 'number' && maxLength > 0 ? maxLength : undefined;
+  };
+
   /**
    * [#7230, #21878] The field whose value titles a record of `objectName` in
    * an activity row — ADR-0079's `resolveDisplayField` over the registered
@@ -2125,7 +2241,8 @@ export function installAuditWriters(
     } else {
       // ADR-0052 §5b — declarative activity, precedence: a configured semantic
       // milestone (§5b.2) wins; else a tracked field-change diff ("Stage:
-      // Proposal → Closed Won", §5b.1); else the generic fallback.
+      // Proposal → Closed Won", §5b.1); else the generic fallback, naming the
+      // changed fields but not their values (#25787).
       // [#6656] Masked views, not the raw pair. The milestone branch
       // interpolates `{field}` from the after-row straight into a summary the
       // record feed and Setup dashboards render verbatim, so it must never see
@@ -2183,9 +2300,24 @@ export function installAuditWriters(
           summary = tracked.text;
           summarySources = tracked.fields;
         } else {
-          summary =
-            translate('messages.activityUpdated', { object: objectDisplay, label }) ??
-            `Updated ${objectDisplay} "${label}"`;
+          // [#25787] No tracked field changed: name the fields that did.
+          const named = renderChangedFieldsSummary(
+            ctx.object,
+            summaryFields,
+            newValue,
+            translate,
+            locale,
+            { object: objectDisplay, label },
+            activitySummaryMaxLength(),
+          );
+          if (named) {
+            summary = named.text;
+            summarySources = [...new Set([...labelSources, ...named.fields])];
+          } else {
+            summary =
+              translate('messages.activityUpdated', { object: objectDisplay, label }) ??
+              `Updated ${objectDisplay} "${label}"`;
+          }
         }
       }
     }