@@ -0,0 +1,12 @@
+---
+'@objectstack/spec': minor
+---
+
+fix(spec): the error-code ledger records `@objectstack/mcp` as an emitter of `OBJECT_API_DISABLED` and `OBJECT_API_METHOD_NOT_ALLOWED` (#22664)
+
+Clause-②: yes
+
+- **`ERROR_CODE_LEDGER` gains the `@objectstack/mcp` owner key.** The MCP stdio data bridge stamps both exposure codes onto the error it throws when an object's `enable` block refuses a data verb: `OBJECT_API_DISABLED` (404) for `apiEnabled: false`, and `OBJECT_API_METHOD_NOT_ALLOWED` (405) for an `apiMethods` whitelist that does not grant the verb. The published type of `ERROR_CODE_LEDGER` gains the key. `ErrorCode` and `REGISTERED_ERROR_CODES` are unchanged, because both codes were already registered under `@objectstack/rest`.
+- **`PROVENANCE_WAIVERS` gains one entry:** `@objectstack/types` → `UNIQUE_SCOPE_CONFIRMATION_REQUIRED`, registered under `@objectstack/cloud-connection`. `@objectstack/types` defines the shared constant `GLOBAL_UNIQUE_CONFIRMATION_REQUIRED`. The one stamp is the marketplace install seam's 409 in `@objectstack/cloud-connection`, whose owner key already lists the code.
+
+No code is added, renamed or removed, and no schema moves.
@@ -22,7 +22,11 @@ import {
   deriveFindings,
   type StampSite,
 } from './check-error-code-provenance';
-import { ERROR_CODE_LEDGER, type ProvenanceWaiver } from '../src/api/error-code-ledger.zod';
+import {
+  ERROR_CODE_LEDGER,
+  PROVENANCE_WAIVERS,
+  type ProvenanceWaiver,
+} from '../src/api/error-code-ledger.zod';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 
@@ -64,6 +68,29 @@ describe('STAMP_PATTERNS (published, one pin per pattern)', () => {
       .toEqual([{ code: 'REGISTERED_ONE', pattern: 'constdef', line: 1 }]);
   });
 
+  it('constdef: a DECLARED constant of any name is a site — the binding, not its name, says "code"', () => {
+    // The shape the `*_CODE` name rule could not see: a constant named after
+    // the code it holds (the stdio bridge), exported, `as const`, `let`, typed.
+    expect(scanSourceText("const OBJECT_API_DISABLED = 'REGISTERED_ONE';", registered))
+      .toEqual([{ code: 'REGISTERED_ONE', pattern: 'constdef', line: 1 }]);
+    expect(scanSourceText("export const SELF_REGISTRATION_CLOSED = 'REGISTERED_ONE' as const;", registered))
+      .toEqual([{ code: 'REGISTERED_ONE', pattern: 'constdef', line: 1 }]);
+    expect(scanSourceText("let code = 'REGISTERED_ONE';", registered))
+      .toEqual([{ code: 'REGISTERED_ONE', pattern: 'constdef', line: 1 }]);
+    expect(scanSourceText("const DATASET_INVALID: RegisteredErrorCode = 'REGISTERED_ONE';", registered))
+      .toEqual([{ code: 'REGISTERED_ONE', pattern: 'constdef', line: 1 }]);
+  });
+
+  it('constdef keeps the keyword-less *_CODE limb, so the widening is a superset of the name rule', () => {
+    expect(scanSourceText("static readonly MY_CODE = 'REGISTERED_ONE';", registered))
+      .toEqual([{ code: 'REGISTERED_ONE', pattern: 'constdef', line: 1 }]);
+  });
+
+  it('constdef reads a declaration: a re-assignment to a non-*_CODE name and a comparison are not sites', () => {
+    expect(scanSourceText("status = 'REGISTERED_ONE';", registered)).toEqual([]);
+    expect(scanSourceText("if (e.code === 'REGISTERED_ONE') return;", registered)).toEqual([]);
+  });
+
   it('an unregistered code is out of population — the dispatcher-vocabulary gate owns it', () => {
     expect(scanSourceText("return { code: 'NOT_IN_ANY_LEDGER' };", registered)).toEqual([]);
   });
@@ -150,6 +177,48 @@ describe('deriveFindings — the reconciliation, both directions', () => {
   });
 });
 
+describe('@objectstack/mcp: the stdio bridge\'s exposure constants are seen, and their rows hold them', () => {
+  // The bridge's two declarations, verbatim (`packages/mcp/src/stdio-data-bridge.ts`),
+  // driven through the scan and the REAL ledger — copied rather than read, so
+  // this suite still reads nothing outside its package. The repo-wide CI run of
+  // the gate is what holds the file itself.
+  const BRIDGE_SOURCE = [
+    "const OBJECT_API_DISABLED = 'OBJECT_API_DISABLED';",
+    "const OBJECT_API_METHOD_NOT_ALLOWED = 'OBJECT_API_METHOD_NOT_ALLOWED';",
+  ].join('\n');
+  const realRegistered = new Set<string>(Object.values(ERROR_CODE_LEDGER).flat());
+  const bridgeSites = (): StampSite[] =>
+    scanSourceText(BRIDGE_SOURCE, realRegistered).map((hit) => ({
+      file: 'packages/mcp/src/stdio-data-bridge.ts',
+      package: '@objectstack/mcp',
+      ...hit,
+    }));
+
+  it('the scan sees both constants', () => {
+    expect(bridgeSites().map((s) => `${s.code} (${s.pattern})`)).toEqual([
+      'OBJECT_API_DISABLED (constdef)',
+      'OBJECT_API_METHOD_NOT_ALLOWED (constdef)',
+    ]);
+  });
+
+  it('the real ledger lists both under @objectstack/mcp', () => {
+    const findings = deriveFindings(bridgeSites(), ERROR_CODE_LEDGER, PROVENANCE_WAIVERS);
+    expect(findings.violations).toEqual([]);
+    expect(findings.listed).toHaveLength(2);
+  });
+
+  it('RED LEG: with the @objectstack/mcp rows removed the gate reports both sites — no waiver stands in', () => {
+    const withoutMcp = Object.fromEntries(
+      Object.entries(ERROR_CODE_LEDGER).filter(([owner]) => owner !== '@objectstack/mcp'),
+    );
+    const findings = deriveFindings(bridgeSites(), withoutMcp, PROVENANCE_WAIVERS);
+    expect(findings.violations.map((v) => `${v.package} → ${v.code}`)).toEqual([
+      '@objectstack/mcp → OBJECT_API_DISABLED',
+      '@objectstack/mcp → OBJECT_API_METHOD_NOT_ALLOWED',
+    ]);
+  });
+});
+
 describe('rows the scan cannot see, pinned by hand (the declared helper-call blind spot)', () => {
   // The gate's header declares it BLIND to a helper indirection (a
   // `makeError(code, …)` call site) and makes widening its patterns a card of
 
@@ -55,15 +55,26 @@
  *     `apps/`, not `examples/`, not package `scripts/` trees.
  *   - The ledger file itself is excluded by name: its waiver tables spell
  *     `code: '…'` about codes, which is mention, not stamping.
+ *   - A CONSTANT is read at its definition, by its initializer, whatever its
+ *     name (`constdef`). The rule used to be the NAME — a `*_CODE` binding —
+ *     and that proxy missed eleven declared constants in five packages, three
+ *     of them with no provenance record at all (#22664). Two consequences are
+ *     declared rather than left implicit: the site is attributed to the
+ *     package that DEFINES the constant, so a second package that imports it
+ *     and stamps it is not seen as a second emitter (a shared constant one
+ *     package over is the ledger's waiver class:
+ *     `UNIQUE_SCOPE_CONFIRMATION_REQUIRED`, `UPDATE_ID_MISMATCH`); and a
+ *     constant that is only ever COMPARED against is still a site — the
+ *     over-match bound below, measured at zero such constants when the rule
+ *     widened.
  *   - BLIND, and inheriting the sibling gate's declared blindness rather than
- *     re-litigating it: a code arriving through a constant NOT named `*_CODE`
- *     (`GLOBAL_UNIQUE_CONFIRMATION_REQUIRED` in `@objectstack/types` defines a
- *     registered code and is invisible here), an object-literal or helper
- *     indirection (`{ code }` shorthand, `makeError(code, …)` call sites), a
- *     template literal, and a class field. Those shapes DO have recognizers in
- *     the sibling gate; a registered code reaching a stamp through one of them
- *     is simply not this gate's finding yet. Widening is a gate-population
- *     change with an unmeasured blast radius — its own card, never a rider.
+ *     re-litigating it: an object-literal or helper indirection (`{ code }`
+ *     shorthand, `makeError(code, …)` call sites, a `cond ? 'A' : 'B'` or
+ *     `?? 'X'` operand), a template literal, and a class field. Those shapes
+ *     DO have recognizers in the sibling gate; a registered code reaching a
+ *     stamp through one of them is simply not this gate's finding yet.
+ *     Widening is a gate-population change with an unmeasured blast radius —
+ *     its own card, never a rider.
  *   - OVER-matching is accepted and absorbed by rows/waivers rather than
  *     heuristics: a TYPE-position literal (`{ code: 'ITEM_LOCKED'; reason:
  *     string }`) matches the object-literal pattern. That is deliberate — the
@@ -109,10 +120,20 @@ export const STAMP_PATTERNS: ReadonlyArray<{ name: string; re: RegExp }> = [
   { name: 'objlit', re: /\bcode:\s*'([A-Z][A-Z0-9_]*)'/g },
   // `err.code = 'X'` — stamped onto a value about to be thrown.
   { name: 'assign', re: /\.code\s*=\s*'([A-Z][A-Z0-9_]*)'/g },
-  // `X_CODE = 'X'` — a `*_CODE`-named constant's literal initializer (the
-  // driver-memory `UNIQUE_VIOLATION_CODE` shape). The optional `[^=\n]*?`
-  // limb admits a type annotation between name and `=`.
-  { name: 'constdef', re: /\b[A-Z][A-Z0-9_]*_CODE\s*(?::[^=\n]*?)?=\s*'([A-Z][A-Z0-9_]*)'/g },
+  // A constant whose literal initializer is a registered code: the binding is
+  // the site, whatever it is named. Two limbs:
+  //   - `const|let|var NAME = 'X'` — a DECLARED binding of any name (the
+  //     `@objectstack/mcp` stdio bridge's `const OBJECT_API_DISABLED = …`, the
+  //     plugin-auth `SELF_REGISTRATION_CLOSED` shape). The registered set is
+  //     the filter, so the name no longer has to say "code".
+  //   - `X_CODE = 'X'` — a `*_CODE`-named binding with no keyword in front (a
+  //     class `static readonly`, a second declarator), kept so the widening
+  //     is a superset of the name rule it replaced, never a trade.
+  // The optional `[^=\n]*?` limb admits a type annotation between name and `=`.
+  {
+    name: 'constdef',
+    re: /(?:\b(?:const|let|var)\s+[A-Za-z_$][\w$]*|\b[A-Z][A-Z0-9_]*_CODE)\s*(?::[^=\n]*?)?=\s*'([A-Z][A-Z0-9_]*)'/g,
+  },
 ];
 
 export interface StampSite {
@@ -301,8 +322,9 @@ export function deriveFindings(
 
 function printBounds(): void {
   console.log('bounds: packages/**/src non-test .ts/.tsx; ledger file excluded (mention, not stamping);');
-  console.log(`bounds: patterns = ${STAMP_PATTERNS.map((p) => p.name).join(', ')} — blind to non-*_CODE constants,`);
-  console.log('bounds: helper/shorthand indirections, templates and class fields (see the header; sibling-gate shapes).');
+  console.log(`bounds: patterns = ${STAMP_PATTERNS.map((p) => p.name).join(', ')} — a constant is read at its definition`);
+  console.log('bounds: and attributed to the DEFINING package; blind to helper/shorthand/ternary indirections, templates');
+  console.log('bounds: and class fields (see the header; sibling-gate shapes).');
 }
 
 function run(report: boolean): number {
@@ -411,8 +433,8 @@ let selfTestReachedVerdict = false;
 // The counts are a FLOOR, not an equality: adding cases is ordinary work and
 // must not red. A battery BELOW its floor means cases stopped running.
 const SELF_TEST_BATTERIES: Readonly<Record<string, number>> = Object.freeze({
-  'each published STAMP pattern catches its own spelling': 4,
-  'the population boundary and comment masking: what is NOT a site': 2,
+  'each published STAMP pattern catches its own spelling': 6,
+  'the population boundary and comment masking: what is NOT a site': 4,
   'the reconciliation: an unlisted stamper reddens, a listed one is green': 2,
   'a waiver admits EXACTLY its (package, code) pair': 2,
   'every stale-waiver direction reddens': 3,
@@ -492,13 +514,34 @@ function selfTest(): number {
     'constdef admits a type annotation',
     scanSourceText(`const MY_CODE: string = '${CODE_A}';`, registered).some((h) => h.pattern === 'constdef'),
   );
+  // The binding is the site whatever it is named — the stdio-bridge shape the
+  // `*_CODE` name rule could not see.
+  check(
+    'constdef catches a declared constant of ANY name',
+    scanSourceText(`const REFUSAL = '${CODE_A}';`, registered).some((h) => h.pattern === 'constdef'),
+  );
+  // …and the keyword-less `*_CODE` limb keeps the widening a superset.
+  check(
+    'constdef keeps a keyword-less *_CODE binding',
+    scanSourceText(`static readonly MY_CODE = '${CODE_A}';`, registered).some((h) => h.pattern === 'constdef'),
+  );
   // Population boundary: a code outside the registered set is the sibling
   // gate's subject, never a site here.
   battery('the population boundary and comment masking: what is NOT a site');
   check(
     'a code outside the registered set is out of population',
     scanSourceText(`return { code: '${CODE_OUT}' };`, registered).length === 0,
   );
+  // Precision of the widened `constdef`: it reads a DECLARATION, so neither a
+  // re-assignment to an undeclared non-`*_CODE` name nor a comparison is one.
+  check(
+    'a re-assignment to a non-*_CODE name is not a site',
+    scanSourceText(`status = '${CODE_A}';`, registered).length === 0,
+  );
+  check(
+    'a comparison against a registered code is not a site',
+    scanSourceText(`if (e.code === '${CODE_A}') return;`, registered).length === 0,
+  );
   // Comment masking: a code quoted in prose is not a site.
   check(
     'a commented stamp is not a site',
 
@@ -1127,6 +1127,19 @@ export const ERROR_CODE_LEDGER = {
     'RAW_SQL_UNSUPPORTED',
     'READ_SCOPE_COMPILE_FAILED',   // [#5367] RLS read-scope lowering failed fail-closed — a SERVER fault (500), never the caller's
   ],
+  '@objectstack/mcp': [
+    // [#22664] The stdio data bridge's exposure gate (`stdio-data-bridge.ts`,
+    // `enforceApiExposure`) stamps the data door's two exposure codes onto the
+    // thrown `McpExposureError.code` — 404 for `apiEnabled: false`, 405 with
+    // `allowedOperations` for a whitelist that does not grant the verb — before
+    // every stdio data verb and the ADR-0101 record resource. The stdio data
+    // tools flatten the throw to its message (`errorResult(messageOf(err))`),
+    // so no MCP result carries the code today: a `door: 'none'` row under the
+    // "door or no door" ruling above. `@objectstack/rest` keeps its own rows
+    // for the data door.
+    'OBJECT_API_DISABLED',
+    'OBJECT_API_METHOD_NOT_ALLOWED',
+  ],
   '@objectstack/service-datasource': [
     'DATASOURCE_ADMIN_ERROR',      // lifecycle/validation refusal from the datasource-admin service
     'EXTERNAL_DATASOURCE_ERROR',   // introspection/connection-test refusal from the external-datasource service
@@ -1871,6 +1884,16 @@ export const PROVENANCE_WAIVERS: readonly ProvenanceWaiver[] = [
       'throws are served under the emitting doors\' own registrations (runtime\'s ' +
       'dispatcher exits, rest\'s `mapDataError` — both packages list the code).',
   },
+  {
+    package: '@objectstack/types',
+    code: 'UNIQUE_SCOPE_CONFIRMATION_REQUIRED',
+    registeredUnder: '@objectstack/cloud-connection',
+    reason: 'Shared constant one package over: `GLOBAL_UNIQUE_CONFIRMATION_REQUIRED` ' +
+      '(unique-scope-install-gate.ts) spells the string beside the ADR-0120 D5e posture ' +
+      'gate it names, and the one stamp is the marketplace install seam\'s 409 ' +
+      '(`marketplace-install-local-plugin.ts`), which answers it on the plugin\'s own Hono ' +
+      'route — the cloud-connection row records that door. Types ships no door.',
+  },
   {
     package: '@objectstack/core',
     code: 'ANALYTICS_DATE_RANGE_UNRECOGNIZED',