@@ -0,0 +1,16 @@
+---
+'@objectstack/metadata': patch
+'@objectstack/objectql': patch
+'@objectstack/cli': patch
+---
+
+refactor(metadata, objectql, cli): one spelling of the residual-picklist refusal, and one envelope for two registration refusals
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+Nothing a stack can declare is refused or accepted differently, and every refusal keeps its code, status and words byte for byte. What moves is where each judgement is written, so the doors that give the same answer read it from one place.
+
+- **New subpath `@objectstack/metadata/picklist-references`.** It exports `unreferencedResidualPicklists(residual, bodies)`: given a composed stack's residual (what `unclaimedTopLevel` answers) and its package bodies, it returns every top-level picklist that no package body declares and no object field the engine registers names, each with its location and words, plus the one plural sentence for all of them, or `undefined` when there is none. It also exports the manifest picklist walk the engine already used (`collectManifestPicklistReferences`, `collectPicklistReferences`, `collectManifestPicklistNames`, `collectManifestPicklistExtensions`) and the types `PicklistReference`, `OrphanPicklistExtension`, `ResidualPicklistInput`, `ResidualPicklistWording`, `UnreferencedResidualPicklist` and `UnreferencedResidualPicklists`.
+- **`@objectstack/objectql`** re-exports `unreferencedResidualPicklists` and its four types from the package root. The `manifest` service's `INVALID_METADATA` refusal of such a picklist is now that judgement's sentence, and the engine's picklist walk is the one in `@objectstack/metadata`. The residual registration of a composed stack now throws the body seam's own refusals for a permission set whose `packageId` names another package (`VALIDATION_ERROR` / 400 with `issues[]`) and for a `views:` entry that is not a view container (`INVALID_METADATA` / 422), instead of rebuilding each.
+- **`@objectstack/cli`**: the `picklist-residual-unreferenced` finding of `os validate` and `os build` is read from the same judgement. Its `--json` shape (`severity`, `rule`, `where`, `path`, `message`, `hint`) and its text are unchanged.
@@ -5,15 +5,18 @@
  * stack's top-level picklist that no package body declares and no object field
  * the engine registers names is refused by the boot (the engine's `manifest`
  * service, `INVALID_METADATA`), and `judgePicklistReferences` refuses the same
- * stacks as `picklist-residual-unreferenced`, in the same words.
+ * stack as `picklist-residual-unreferenced`, in the same words.
  *
- * The engine does not export its judgement, so the author-time door restates
- * it. This file is what keeps the two from drifting. Each stack is judged by
- * the door and booted on a real kernel with the real `ObjectQLPlugin`, the way
- * `AppPlugin` hands a config boot's stack to the `manifest` service
- * (`{ ...manifest, ...stack }`). Where the door refuses one list, the boot
- * throws `${message} ${hint}` byte for byte; where the door raises no such
- * refusal, the boot does not throw this one.
+ * Both read ONE judgement, `unreferencedResidualPicklists`
+ * (`@objectstack/metadata/picklist-references`, re-exported by
+ * `@objectstack/objectql`), so this file is a smoke check of the wiring, not
+ * the guard against drift: one refused stack and one control, booted on a real
+ * kernel with the real `ObjectQLPlugin`, the way `AppPlugin` hands a config
+ * boot's stack to the `manifest` service (`{ ...manifest, ...stack }`). Which
+ * lists are refused, judged off which fields, is pinned on the judgement and
+ * at each door: `picklist-references.test.ts` here, and objectql's
+ * `manifest-service-residual-objects.test.ts` and
+ * `registration-refusal-one-spelling.test.ts`.
  */
 
 import { afterEach, describe, expect, it } from 'vitest';
@@ -31,8 +34,6 @@ const unused = { name: 'parity_unused', label: 'Unused', options: [{ label: 'A',
 const statusField = { status: { type: 'select', label: 'Status', picklist: 'parity_status' } };
 const caseObj = (fields: AnyRec = { subject: { type: 'text', label: 'Subject' } }) =>
   ({ name: 'parity_case', label: 'Case', sharingModel: 'private', fields });
-const noteObj = (fields: AnyRec = { title: { type: 'text', label: 'Title' } }) =>
-  ({ name: 'parity_note', label: 'Note', sharingModel: 'private', fields });
 
 /** Two bodies, a manifest naming neither, and `top` on the top level. */
 const composed = (top: AnyRec, coreExtra: AnyRec = {}): AnyRec => ({
@@ -44,27 +45,10 @@ const composed = (top: AnyRec, coreExtra: AnyRec = {}): AnyRec => ({
   ],
 });
 
-/** Every stack the door's pins name, the refused and the controls alike. */
+/** One refused stack and one control. */
 const STACKS: Record<string, AnyRec> = {
   'a list nothing names': composed({ picklists: [unused] }),
-  'a list only a top-level `objectExtensions` entry names': composed({
-    picklists: [unused], objectExtensions: [{ extend: 'parity_case', fields: { u: { type: 'select', label: 'U', picklist: 'parity_unused' } } }],
-  }),
-  'a list only a diverging top-level copy of a body object names': composed({
-    picklists: [unused], objects: [caseObj({ u: { type: 'select', label: 'U', picklist: 'parity_unused' } })],
-  }),
-  'a list only a body `picklistExtensions` entry extends': composed({ picklists: [unused] }, {
-    picklistExtensions: [{ extend: 'parity_unused', options: [{ label: 'Closed', value: 'closed' }] }],
-  }),
-  'a list only a top-level `plugins[]` entry\'s object names': composed({
-    picklists: [unused], plugins: [{ name: 'parity_plugin', objects: [noteObj({ u: { type: 'select', label: 'U', picklist: 'parity_unused' } })] }],
-  }),
-  'CONTROL: a list a residual object\'s field names': composed({
-    picklists: [unused], objects: [noteObj({ u: { type: 'select', label: 'U', picklist: 'parity_unused' } })],
-  }),
-  'CONTROL: a body-declared list repeated on the top level': composed({ picklists: [status] }),
   'CONTROL: a body-declared list a body field names': composed({}, { objects: [caseObj(statusField)] }),
-  'CONTROL: a stack without `packages[]`': { manifest: manifest(STACK_ID), picklists: [unused], objects: [noteObj()] },
 };
 
 const kernels: ObjectKernel[] = [];
 
@@ -16,6 +16,8 @@
  */
 
 import { describe, expect, it } from 'vitest';
+import { unclaimedTopLevel } from '@objectstack/metadata';
+import { unreferencedResidualPicklists } from '@objectstack/metadata/picklist-references';
 import {
   judgePicklistReferences,
   picklistRefusalHeading,
@@ -336,8 +338,9 @@ describe('judgePicklistReferences — a `picklistExtensions[].extend` in a `pack
  * [ADR-0130 D4] A composed stack's top-level picklist that no package body
  * declares and no object field the boot registers names: the boot refuses the
  * stack (`INVALID_METADATA`), so this door refuses it too, as
- * `picklist-residual-unreferenced`, in the boot's words. The boot's own text is
- * held equal in `picklist-references.boot-parity.test.ts`.
+ * `picklist-residual-unreferenced`, in the boot's words. Both read the one
+ * judgement, `unreferencedResidualPicklists`; the last pin below holds the door
+ * to it, and `picklist-references.boot-parity.test.ts` smoke-checks the boot.
  */
 describe('judgePicklistReferences — a composed stack\'s residual picklist that nothing names', () => {
   const STACK_ID = 'com.example.release';
@@ -422,6 +425,23 @@ describe('judgePicklistReferences — a composed stack\'s residual picklist that
     expect(judgePicklistReferences({ manifest: manifest('com.example.pk'), picklists: [industry, unused], objects: [account('industry')] }))
       .toEqual({ refusals: [], notices: [] });
   });
+
+  it('reports the one judgement the boot throws — its lists, their locations and its words, one finding per list', () => {
+    const stack = composed({ picklists: [industry, unused, { ...unused, name: 'spare_list' }] });
+    const judged = unreferencedResidualPicklists(
+      unclaimedTopLevel(stack),
+      stack.packages.map((entry) => entry.manifest),
+    );
+    expect(judged?.picklists).toHaveLength(2);
+    expect(residualRefusals(stack)).toEqual(judged!.picklists.map((list) => ({
+      severity: 'error',
+      rule: PICKLIST_RESIDUAL_UNREFERENCED,
+      where: `picklist "${list.name}"`,
+      path: `${list.field}[${list.index}]`,
+      message: list.wording.judgement,
+      hint: list.wording.prescription,
+    })));
+  });
 });
 
 describe('picklistRefusalHeading — the text face\'s heading names what each rule refused', () => {
 
@@ -47,9 +47,9 @@
  * The boot keeps a composed stack's residual picklist (a top-level one no
  * body declares) as metadata only, and refuses the stack when no object field
  * the engine registers names it (ADR-0130 D4). This door gives the same
- * refusal, in the boot's words, as {@link PICKLIST_RESIDUAL_UNREFERENCED}, so
- * `os validate` and `os build` foretell it. See
- * `findUnreferencedResidualPicklists`.
+ * refusal as {@link PICKLIST_RESIDUAL_UNREFERENCED}, read from the boot's own
+ * judgement (`unreferencedResidualPicklists`), so `os validate` and `os build`
+ * foretell it in the boot's words. See `findUnreferencedResidualPicklists`.
  *
  * ## Declared dependencies outside the stack: reported, never refused
  *
@@ -93,6 +93,7 @@
 import chalk from 'chalk';
 import type { AuthoringFinding } from '@objectstack/lint';
 import { unclaimedTopLevel } from '@objectstack/metadata';
+import { unreferencedResidualPicklists } from '@objectstack/objectql';
 
 import { artifactPackages } from './artifact-packages.js';
 import { printInfo } from './format.js';
@@ -335,60 +336,6 @@ export function judgePicklistReferences(parsed: AnyRec): PicklistReferenceJudgem
   return { refusals, notices };
 }
 
-/**
- * The picklist names a manifest-shaped source's fields carry: its `objects`
- * and `objectExtensions`, in either field spelling (a name-keyed record or an
- * array), and the same of each nested `plugins[]` entry that is a plain
- * object. That is the reading the boot's `collectManifestPicklistReferences`
- * (`@objectstack/objectql`) makes of a source it registers. The stack parse
- * refuses a `plugins` key inside a `packages[]` body today; it is walked anyway
- * so this set stays the engine's.
- */
-function fieldPicklistNamesOf(source: unknown): string[] {
-  const names: string[] = [];
-  const rec = asRec(source);
-  if (!rec) return names;
-  const nested = Array.isArray(rec.plugins) ? rec.plugins.map(asRec).filter((p): p is AnyRec => p !== undefined) : [];
-  for (const s of [rec, ...nested]) {
-    for (const collection of ['objects', 'objectExtensions'] as const) {
-      const raw = s[collection];
-      const entries = Array.isArray(raw) ? raw : (asRec(raw) ? Object.values(raw as AnyRec) : []);
-      for (const entry of entries) {
-        const fields = asRec(entry)?.fields;
-        const defs = Array.isArray(fields) ? fields : (asRec(fields) ? Object.values(fields as AnyRec) : []);
-        for (const def of defs) {
-          const picklist = asRec(def)?.picklist;
-          if (typeof picklist === 'string' && picklist !== '') names.push(picklist);
-        }
-      }
-    }
-  }
-  return names;
-}
-
-/**
- * The boot's judgement of an unreferenced residual picklist, for one list, in
- * the boot's words: what `ObjectQLPlugin`'s `manifest` service throws
- * (`unreferencedResidualPicklistRefusal`, `INVALID_METADATA`) is
- * `${judgement} ${prescription}`. Restated here because the engine does not
- * export it; `picklist-references.boot-parity.test.ts` boots the engine on the
- * same stacks and holds the two equal.
- */
-function residualPicklistWording(name: string, owner: string): { judgement: string; prescription: string } {
-  return {
-    judgement:
-      `Picklist '${name}' is declared on the top level of stack '${owner}', and no package body declares it and no `
-      + 'object field the engine registers names it (in a composed stack, a top-level `objectExtensions` entry, a '
-      + 'top-level copy of an object a package body declares and a top-level `plugins[]` entry are not registered). '
-      + 'The engine registers a top-level picklist only through a package body, so this list would be missing from '
-      + 'the engine with nothing said.',
-    prescription:
-      'Declare it inside the `packages[]` entry of the package whose objects use it; or name it from a field of '
-      + 'the object meant to use it (a top-level object that does is then listed and not served until both move '
-      + 'into a package body); or remove it from the top level.',
-  };
-}
-
 /**
  * [ADR-0130 D4] Every top-level picklist of a composed stack (one that carries
  * `packages[]`) that no package body declares and no object field the boot
@@ -397,40 +344,30 @@ function residualPicklistWording(name: string, owner: string): { judgement: stri
  * whose top level IS its one package.
  *
  * Which items are residual is the residual rule's answer (`unclaimedTopLevel`,
- * `@objectstack/metadata`), never re-derived here. "Named" is the boot's set:
- * a field of a body's `objects` / `objectExtensions` / nested `plugins[]`, or
- * of a residual object. A top-level `objectExtensions` entry, a top-level copy
- * of an object a body declares and a top-level `plugins[]` entry name nothing,
- * because no door registers them in a composed stack.
+ * `@objectstack/metadata`); which of its lists nothing names, and the words,
+ * are the boot's own judgement, `unreferencedResidualPicklists` (re-exported by
+ * `@objectstack/objectql`), which the `manifest` service throws as one
+ * sentence. This door only reports it, one finding per list, located at the
+ * list's top-level index. ⛔ Never re-derived or re-worded here.
  *
  * A residual picklist that a field DOES name is not this judge's: a residual
  * object's field makes that object listed and not served at boot, and a
  * body's field is {@link PICKLIST_REFERENCE_UNKNOWN} above.
  */
 function findUnreferencedResidualPicklists(parsed: AnyRec): AuthoringFinding[] {
   if (parsed.packages === undefined) return [];
-  const residual = unclaimedTopLevel(parsed);
-  const lists = residual?.items.filter((entry) => entry.type === 'picklist') ?? [];
-  if (!residual || lists.length === 0) return [];
-  const named = new Set<string>();
-  for (const pkg of artifactPackages(parsed)) for (const name of fieldPicklistNamesOf(pkg.body)) named.add(name);
-  const residualObjects = residual.items.filter((entry) => entry.type === 'object').map((entry) => entry.item);
-  for (const name of fieldPicklistNamesOf({ objects: residualObjects })) named.add(name);
-  const owner = residual.ownerId ?? '<none>';
-  return lists
-    .map((entry) => ({ entry, name: String(asRec(entry.item)?.name) }))
-    .filter(({ name }) => !named.has(name))
-    .map(({ entry, name }) => {
-      const wording = residualPicklistWording(name, owner);
-      return {
-        severity: 'error' as const,
-        rule: PICKLIST_RESIDUAL_UNREFERENCED,
-        where: `picklist "${name}"`,
-        path: `${entry.field}[${entry.index}]`,
-        message: wording.judgement,
-        hint: wording.prescription,
-      };
-    });
+  const unreferenced = unreferencedResidualPicklists(
+    unclaimedTopLevel(parsed),
+    artifactPackages(parsed).map((pkg) => pkg.body),
+  );
+  return (unreferenced?.picklists ?? []).map((list) => ({
+    severity: 'error' as const,
+    rule: PICKLIST_RESIDUAL_UNREFERENCED,
+    where: `picklist "${list.name}"`,
+    path: `${list.field}[${list.index}]`,
+    message: list.wording.judgement,
+    hint: list.wording.prescription,
+  }));
 }
 
 /**
 
@@ -67,6 +67,16 @@
         "types": "./dist/view-container-name.d.cts",
         "default": "./dist/view-container-name.cjs"
       }
+    },
+    "./picklist-references": {
+      "import": {
+        "types": "./dist/picklist-references.d.ts",
+        "default": "./dist/picklist-references.js"
+      },
+      "require": {
+        "types": "./dist/picklist-references.d.cts",
+        "default": "./dist/picklist-references.cjs"
+      }
     }
   },
   "files": [