@@ -103,6 +103,7 @@
  *   pages.<page>.label / .description
  *   pages.<page>.title / .subtitle   (from the page's `page:header` component)
  *   pages.<page>.components.<id>.<key>  (per-component copy, #6080)
+ *   pages.<page>.components.<tabsId>.items.<value>.label  (a `page:tabs` item label)
  *   flows.<flow>.label
  *   flows.<flow>.screens.<node_id>.title                       (#7646 / #11287)
  *   flows.<flow>.screens.<node_id>.description                 (#22507)
@@ -137,7 +138,9 @@ import {
   FLOW_SCREEN_COPY_KEYS,
   FLOW_SCREEN_FIELD_COPY_KEYS,
   FLOW_TERMINAL_MESSAGE_KEYS,
+  PAGE_TABS_COMPONENT_TYPE,
   globalFilterKey,
+  pageTabItemKey,
   walkAddressedPageComponents,
 } from '@objectstack/spec/system';
 import { FLOW_REGION_SLOTS_BY_TYPE, flowScreenFieldOptionKey } from '@objectstack/spec/automation';
@@ -1169,6 +1172,22 @@ function emitPageComponentCopy(out: ExpectedEntry[], page: any, name: string): v
         // records nothing (#14749).
         pushEntry(out, ['pages', name, 'components', id as string, key], value, 'page');
       }
+      // A `page:tabs` component's tab labels, keyed by each item's `value`
+      // under the tabs component's id — the key `translatePage` reads. An
+      // item without a `value` gets no slot: its renderer token is
+      // index-derived, and an array index is never a bundle key (#14749).
+      if (component.type === PAGE_TABS_COMPONENT_TYPE && Array.isArray(props.items)) {
+        for (const item of props.items as unknown[]) {
+          const value = pageTabItemKey(item);
+          if (value === undefined) continue;
+          pushEntry(
+            out,
+            ['pages', name, 'components', id as string, 'items', value, 'label'],
+            (item as Record<string, unknown>).label,
+            'page',
+          );
+        }
+      }
     }
     return component;
   });
 
@@ -209,8 +209,11 @@ import { expandViewContainer } from '@objectstack/spec';
 import { APPROVAL_NODE_TYPE, flowScreenFieldOptionKey } from '@objectstack/spec/automation';
 import {
   FLOW_TERMINAL_MESSAGE_KEYS,
+  PAGE_TABS_COMPONENT_TYPE,
   hasPlatformObjectPrefix,
   isPlatformProvidedObjectName,
+  pageTabItemKey,
+  walkAddressedPageComponents,
 } from '@objectstack/spec/system';
 import { walkFlowNodes } from './flow-walk.js';
 import { packagesOf, recordsOf, suggestName } from './object-graph.js';
@@ -236,6 +239,15 @@ const SCREEN_NODE_TYPE = 'screen';
  * `'refused'` a member of the schema's `outcome` enum, neither exported by name.
  */
 const END_NODE_TYPE = 'end';
+
+/**
+ * The component a misplaced `components.<id>.items` key most often sits on: a
+ * `page:accordion` declares `items[].label` too, but its panels carry no
+ * author-settable identity (the renderer derives `panel-<index>`), so the
+ * verdict points at the inline locale map rather than at a key. A local
+ * const for {@link SCREEN_NODE_TYPE}'s reason.
+ */
+const PAGE_ACCORDION_COMPONENT_TYPE = 'page:accordion';
 const REFUSED_OUTCOME = 'refused';
 
 export const TRANSLATION_TARGET_UNKNOWN = 'translation-target-unknown';
@@ -461,6 +473,22 @@ interface Universe {
    * rung 2b of the object ladder applied to a list (#23566).
    */
   extendedPicklists: Set<string>;
+  /**
+   * Page name (`Page.name`) → every component id the page ADDRESSES
+   * (`pages.<page>.components.<id>`), with that component's type and, for a
+   * `page:tabs`, the item `value`s a `components.<id>.items.<value>` key may
+   * name. Built on spec's `walkAddressedPageComponents`, the walk
+   * `translatePage` itself runs, so an id here is the component the resolver
+   * reads the entry for.
+   */
+  pages: Map<string, Map<string, PageComponentFacts>>;
+}
+
+/** What the `items` check knows about one addressed page component. */
+interface PageComponentFacts {
+  type: string | undefined;
+  /** The `page:tabs` item `value`s (`pageTabItemKey`); empty for any other type. */
+  tabValues: Set<string>;
 }
 
 function emptyFacts(): ObjectFacts {
@@ -1239,6 +1267,38 @@ function buildUniverse(stack: AnyRec): Universe {
   for (const page of recordsOf(stack.pages)) collectPageRecord(page);
   for (const page of artifactProvidedRecords(stack, 'pages')) collectPageRecord(page);
 
+  // ── Pages: the components `pages.<page>.components.<id>` addresses, for the
+  //    `page:tabs` item key (`components.<id>.items.<value>.label`) ──
+  //
+  // Walked with spec's `walkAddressedPageComponents`, NOT lint's
+  // `walkPageComponents`: the key is read by `translatePage`, which runs that
+  // walk (roots, descent, collision arbitration), so the component an id
+  // names here is the one the resolver applies the entry to. Where both this
+  // stack and a sibling package declare a page name, the declaration in hand
+  // keeps the slot — the dashboards rung's `ownDeclaration` decision.
+  const pages = new Map<string, Map<string, PageComponentFacts>>();
+  const collectPageComponents = (page: AnyRec, { ownDeclaration }: { ownDeclaration: boolean }) => {
+    const pageName = strName(page.name);
+    if (!pageName) return;
+    if (!ownDeclaration && pages.has(pageName)) return;
+    const components = new Map<string, PageComponentFacts>();
+    walkAddressedPageComponents(page as Parameters<typeof walkAddressedPageComponents>[0], (component, { id, addressed }) => {
+      if (!addressed || id === undefined) return component;
+      const tabValues = new Set<string>();
+      if (component.type === PAGE_TABS_COMPONENT_TYPE && isRec(component.properties)) {
+        for (const item of Array.isArray(component.properties.items) ? component.properties.items : []) {
+          const value = pageTabItemKey(item);
+          if (value !== undefined) tabValues.add(value);
+        }
+      }
+      components.set(id, { type: strName(component.type), tabValues });
+      return component;
+    });
+    pages.set(pageName, components);
+  };
+  for (const page of recordsOf(stack.pages)) collectPageComponents(page, { ownDeclaration: true });
+  for (const page of artifactProvidedRecords(stack, 'pages')) collectPageComponents(page, { ownDeclaration: false });
+
   // ── Actions: object-bound ones join their object; the rest are global ──
   //
   // …from the stack in hand and from the artifact's other entries (#19349).
@@ -1539,6 +1599,7 @@ function buildUniverse(stack: AnyRec): Universe {
     actionOwners,
     picklists,
     extendedPicklists,
+    pages,
   };
 }
 
@@ -1873,6 +1934,62 @@ export function validateTranslationReferences(stack: AnyRec): TranslationRefFind
         }
       }
 
+      // ── pages.<name>.components.<id>.items.<value> ────────────────────
+      //
+      // Only the `items` member is judged here: it is the one page key whose
+      // target this check can see whole — a declared tabs component's item
+      // `value`s. A page this stack does not declare is skipped (no rung
+      // judges `pages.<name>` itself yet), and so is every other member.
+      for (const [pageName, rawPage] of Object.entries(asRecord(rawData.pages))) {
+        const page = universe.pages.get(pageName);
+        if (!page || !isRec(rawPage)) continue;
+        const pagePath = `${base}.pages.${pageName}`;
+        for (const [componentId, rawComponent] of Object.entries(asRecord(rawPage.components))) {
+          if (!isRec(rawComponent) || rawComponent.items === undefined) continue;
+          const itemsPath = `${pagePath}.components.${componentId}.items`;
+          const where = `${inLocale} · page "${pageName}" · component "${componentId}"`;
+          const tabsHint = 'Tab-item translations go under the `id` of a `page:tabs` component.';
+          const component = page.get(componentId);
+          if (!component) {
+            orphan(
+              where,
+              itemsPath,
+              `Translations carry tab items for "${componentId}", a component id page "${pageName}" does not ` +
+                `declare, so nothing resolves them.` +
+                suggest(componentId, [...page].filter(([, c]) => c.type === PAGE_TABS_COMPONENT_TYPE).map(([id]) => id)),
+              tabsHint,
+            );
+            continue;
+          }
+          if (component.type !== PAGE_TABS_COMPONENT_TYPE) {
+            orphan(
+              where,
+              itemsPath,
+              component.type === PAGE_ACCORDION_COMPONENT_TYPE
+                ? `Translations carry tab items for "${componentId}", which page "${pageName}" declares as a ` +
+                  `\`page:accordion\`, whose panels have no stable key, so nothing resolves them.`
+                : `Translations carry tab items for "${componentId}", which page "${pageName}" declares as a ` +
+                  `\`${component.type ?? 'component'}\`, not a \`page:tabs\`, so nothing resolves them.`,
+              component.type === PAGE_ACCORDION_COMPONENT_TYPE
+                ? 'Localize an accordion panel label in place, as an inline locale map on `items[].label`.'
+                : tabsHint,
+            );
+            continue;
+          }
+          for (const value of Object.keys(asRecord(rawComponent.items))) {
+            if (component.tabValues.has(value)) continue;
+            orphan(
+              `${where} · tab "${value}"`,
+              `${itemsPath}.${value}`,
+              `Translations are keyed to tab "${value}", which \`page:tabs\` "${componentId}" on page ` +
+                `"${pageName}" gives no item as its \`value\`, so the tab keeps its source-locale label.` +
+                suggest(value, component.tabValues),
+              "Tab-item translations are keyed by the item's `value`; give the item a `value` if it has none.",
+            );
+          }
+        }
+      }
+
       // ── picklists.<name>[.options.<value>] (#23566) ───────────────────
       for (const [listName, rawList] of Object.entries(asRecord(rawData.picklists))) {
         const listPath = `${base}.picklists.${listName}`;