@@ -0,0 +1,14 @@
+---
+'@objectstack/metadata-protocol': patch
+---
+
+fix(metadata-protocol): a stored `object_extension` conversion notice names the extension's target, one notice per row
+
+Clause-②: no
+
+Metadata-protocol: none
+
+When a stored row carries a pre-protocol shape, the protocol's read seams print `[Protocol] stored TYPE/NAME carries a pre-protocol shape; …` once per conversion and row. The name was read from the body's `name` key. An `object_extension` body carries `extend` and no `name`, so every stale stored extension was reported as `object_extension/<unnamed>`, and all of them shared one notice: with three stale extensions an operator heard about one, unnamed.
+
+- **Now.** The notice names the item by the identity its type uses, the same one a list read slots it under. An extension is named by its target (`object_extension/crm_account`), and each stale extension row gets its own notice.
+- **Unchanged.** Rows convert exactly as before, and the body is not given a `name`. Every other type is still named by its `name`, and a body with none still reads `<unnamed>`. The `[DatabaseLoader]` notice already named each row by its stored row name, which for an extension is its target.
@@ -0,0 +1,88 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [#29596] The stored-row conversion notice names the item by the identity
+ * its type uses, and the warn-once key separates rows by it.
+ *
+ * An `object_extension` body carries `extend` and no `name`
+ * (`ObjectExtensionSchema` refuses one; its row is stored under the target's
+ * name). Since #29589 a stored extension row replays the `objectExtensions[]`
+ * conversions, so `convertStoredItem` warns for it. Reading `data.name`, it
+ * warned every stale extension as `object_extension/<unnamed>`, and the key
+ * `conversionId|object_extension|` collapsed every row to ONE notice per
+ * conversion. Measured on a real store (SQLite + ObjectQL + the protocol's
+ * save door, two published extensions made stale): six reads, `data.name`
+ * absent on every one, and a single `<unnamed>` line for the two rows.
+ *
+ * Driven through the module's own `convertStoredItem` over the real
+ * conversion chain (`convertStoredItemDetailed`), with the warn-once set the
+ * class hands it.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { convertStoredItem, convertStoredItemDetailed } from './protocol-stored-item-conversion.js';
+
+/** A host shaped like the one the class builds: the real chain, a fresh warn-once set. */
+const host = () => ({ convertStoredItemDetailed, storedConversionWarned: new Set<string>() });
+
+/** A stale extension: the `Z`-suffixed `time` default `time-default-utc-suffix-dropped` converts. */
+const staleExtension = (target: string) => ({
+    extend: target,
+    fields: { opens_at__c: { type: 'time', label: 'Opens', defaultValue: '12:00Z' } },
+});
+
+let warn: { mock: { calls: unknown[][] }; mockRestore(): void };
+beforeEach(() => {
+    warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+afterEach(() => {
+    warn.mockRestore();
+});
+
+/** The `stored TYPE/NAME` subject of each conversion notice, in order. */
+const subjects = () => warn.mock.calls
+    .map((c) => String(c[0]))
+    .filter((line) => line.includes('carries a pre-protocol shape'))
+    .map((line) => /stored (\S+) carries/.exec(line)?.[1]);
+
+describe('[#29596] a stored conversion notice names the item by its identity', () => {
+    it('two stale extension rows give two notices, each naming its target', () => {
+        const h = host();
+        const account = convertStoredItem.call(h, 'object_extension', staleExtension('crm_account'));
+        const contact = convertStoredItem.call(h, 'object_extension', staleExtension('crm_contact'));
+
+        expect(subjects()).toEqual(['object_extension/crm_account', 'object_extension/crm_contact']);
+        // The rows still convert, and the body is not given a `name`.
+        expect(account).toEqual({ extend: 'crm_account', fields: { opens_at__c: { type: 'time', label: 'Opens', defaultValue: '12:00' } } });
+        expect(contact).not.toHaveProperty('name');
+    });
+
+    it('the same extension row read again warns once — the dedupe still holds per row', () => {
+        const h = host();
+        convertStoredItem.call(h, 'object_extension', staleExtension('crm_account'));
+        convertStoredItem.call(h, 'object_extension', staleExtension('crm_account'));
+        convertStoredItem.call(h, 'object_extension', staleExtension('crm_contact'));
+
+        expect(subjects()).toEqual(['object_extension/crm_account', 'object_extension/crm_contact']);
+    });
+
+    it('CONTROL — a non-extension type is still named by its `name`, and a nameless body is still `<unnamed>`', () => {
+        const h = host();
+        const object = (name?: string) => ({
+            ...(name === undefined ? {} : { name }),
+            fields: { opens_at: { type: 'time', defaultValue: '12:00Z' } },
+        });
+        convertStoredItem.call(h, 'object', object('shift'));
+        convertStoredItem.call(h, 'object', object('rota'));
+        convertStoredItem.call(h, 'object', object());
+
+        expect(subjects()).toEqual(['object/shift', 'object/rota', 'object/<unnamed>']);
+    });
+
+    it('CONTROL — an `extend` key on another type does not name it', () => {
+        const h = host();
+        convertStoredItem.call(h, 'object', { extend: 'crm_account', fields: { opens_at: { type: 'time', defaultValue: '12:00Z' } } });
+
+        expect(subjects()).toEqual(['object/<unnamed>']);
+    });
+});
@@ -13,7 +13,9 @@
  * `ObjectStackProtocolImplementation` method of the same name as it stood,
  * re-indented one level and otherwise unedited: the same `flow` exemption,
  * the same chain call, the same warn-once key and text, and the same page
- * default.
+ * default. Since the move, the notice names the item by its list-slot
+ * identity (`listSlotNameOf`), so a stored `object_extension` is named by its
+ * target (#29596).
  *
  * ## How the moved bodies reach the class
  *
@@ -39,6 +41,7 @@ import { applyConversionsToStoredItem, type ConversionNotice, type ConversionTod
 import { PLURAL_TO_SINGULAR } from '@objectstack/spec/shared';
 import type { ObjectStackProtocolImplementation } from './protocol.js';
 import { withDeclaredPageTypeDefault } from './protocol.js';
+import { listSlotNameOf } from './protocol-object-extension-item.js';
 
 /**
  * The `ObjectStackProtocolImplementation` members the functions below read —
@@ -60,7 +63,10 @@ export function convertStoredItem(
 ): unknown {
     const singular = PLURAL_TO_SINGULAR[type] ?? type;
     const converted = this.convertStoredItemDetailed(type, data, (n) => {
-        const name = (data as { name?: unknown } | null | undefined)?.name;
+        // [#29596] The item's identity, not its `name` key: an `object_extension`
+        // body carries `extend` and no `name`, so reading `name` warned every
+        // stored extension as `<unnamed>` and keyed them all to one notice.
+        const name = listSlotNameOf(singular, data);
         const key = `${n.conversionId}|${singular}|${String(name ?? '')}`;
         if (this.storedConversionWarned.has(key)) return;
         this.storedConversionWarned.add(key);
 
@@ -375,6 +375,45 @@ describe('DatabaseLoader', () => {
     });
   });
 
+  // [#29596] The stored-row conversion notice names a row by its row name,
+  // the identity every type is stored under. An `object_extension` body
+  // carries `extend` and no `name`, and its row is stored under its target,
+  // so this seam (unlike the protocol's, which reads the body) already names
+  // each stale extension and keys the warn-once set by it. Measured on a real
+  // store: the two rows read here as `crm_account` and `crm_contact`.
+  describe('stored conversion notice names the row (#29596)', () => {
+    const subjects = (warn: { mock: { calls: unknown[][] } }) => warn.mock.calls
+      .map((c) => String(c[0]))
+      .filter((line) => line.includes('carries a pre-protocol shape'))
+      .map((line) => /stored (\S+) carries/.exec(line)?.[1]);
+    const staleTime = { type: 'time', label: 'Opens', defaultValue: '12:00Z' };
+
+    it('two stale extension rows give two notices, each naming its target', async () => {
+      await loader.save('object_extension', 'crm_account', { extend: 'crm_account', fields: { opens_at__c: staleTime } });
+      await loader.save('object_extension', 'crm_contact', { extend: 'crm_contact', fields: { opens_at__c: staleTime } });
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        const items = await new DatabaseLoader({ driver: mockDriver }).loadMany<{ extend: string; fields: Record<string, { defaultValue: string }> }>('object_extension');
+        expect(items.map((i) => i.fields.opens_at__c.defaultValue)).toEqual(['12:00', '12:00']);
+        expect(subjects(warn)).toEqual(['object_extension/crm_account', 'object_extension/crm_contact']);
+      } finally {
+        warn.mockRestore();
+      }
+    });
+
+    it('CONTROL — a non-extension row is named by its row name the same way', async () => {
+      await loader.save('object', 'shift', { name: 'shift', fields: { opens_at: staleTime } });
+      await loader.save('object', 'rota', { name: 'rota', fields: { opens_at: staleTime } });
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        await new DatabaseLoader({ driver: mockDriver }).loadMany('object');
+        expect(subjects(warn)).toEqual(['object/shift', 'object/rota']);
+      } finally {
+        warn.mockRestore();
+      }
+    });
+  });
+
   describe('stat', () => {
     it('should return null for missing items', async () => {
       const stats = await loader.stat('object', 'missing');