@@ -406,14 +406,15 @@ export default class Compile extends Command {
       //     a finding spanning packages, which is exactly what an empty input
       //     silently stops reporting.
       //
-      //     [#20113] The SDUI manifest is resolved ONCE, over the stack the JSX
-      //     gate judges, and both rule runs are handed the same answer — see
-      //     `validate.ts` step 3 for the three outcomes. Printed here, at the
+      //     [#20113] The SDUI manifest is resolved ONCE, and both rule runs are
+      //     handed the same answer; its pages are counted over the union fold
+      //     AND each package body the pass below judges — see `validate.ts`
+      //     step 3 for the three outcomes. Printed here, at the
       //     gate's step, so the parse-level notice shows on the failing paths
       //     too; it never changes this command's exit status. A project
       //     manifest that exists but cannot be used is refused instead
       //     (already reported on stderr; the catch-all exits 1).
-      const jsxGate = resolveJsxGateManifest(authoringRuleUnionStack(result.data as Record<string, unknown>));
+      const jsxGate = resolveJsxGateManifest(result.data as Record<string, unknown>);
       jsxGateNotices = [...jsxGate.notices];
       if (!flags.json) printJsxGateNotices(jsxGateNotices);
       const findings = runAuthoringRules('build', {
 
@@ -957,8 +957,9 @@ export default class Lint extends Command {
           printWarning(formatConversionNotice(n));
         }
       }
-      // [#20113] The SDUI manifest, resolved once over the stack `lintConfig`
-      // folds to — see `validate.ts` step 3 for the three outcomes. With
+      // [#20113] The SDUI manifest, resolved once; its pages are counted over
+      // the fold `lintConfig` judges AND each package body its per-package
+      // pass judges — see `validate.ts` step 3 for the three outcomes. With
       // `kind:'html'` pages to check and no manifest, the JSX gate runs at
       // parse level and the run SAYS so: one `info` finding, graded
       // `suggestion` by the one mapping, so it rides `issues` and the counts
@@ -967,7 +968,7 @@ export default class Lint extends Command {
       // reaches that function without a manifest and must not score a notice
       // about the filesystem. A project manifest that exists but cannot be
       // used is refused instead (already reported on stderr; exit 1).
-      const jsxGate = resolveJsxGateManifest(authoringRuleUnionStack(normalized as Record<string, unknown>));
+      const jsxGate = resolveJsxGateManifest(normalized as Record<string, unknown>);
       const issues = lintConfig(normalized, { sduiManifest: jsxGate.sduiManifest });
       issues.push(...jsxGate.notices.map(authoringFindingToLintIssue));
 
 
@@ -357,8 +357,11 @@ export default class Validate extends Command {
       //    its collections is returned by identity, so every single-package
       //    project is unaffected by construction.
       //
-      //    [#20113] The SDUI manifest is resolved ONCE, over the stack the JSX
-      //    gate judges, and both rule runs below are handed the same answer.
+      //    [#20113] The SDUI manifest is resolved ONCE, and both rule runs below
+      //    are handed the same answer. Its pages are counted over EVERY stack
+      //    the JSX gate is handed — the union fold AND each package body the
+      //    per-package pass judges — so html pages carried only in `packages[]`
+      //    count beside a top-level `pages` key the fold keeps.
       //    With `kind:'html'` pages to check and no manifest, the gate runs at
       //    parse level and SAYS so — here, at its step, so the line shows on
       //    the failing paths below too, and in `warningsSoFar()` for `--json`.
@@ -368,7 +371,7 @@ export default class Validate extends Command {
       //    this to a failure under `--strict` would break every such project.
       //    A project manifest that exists but cannot be used is REFUSED
       //    instead (thrown, already reported on stderr; the catch-all exits 1).
-      const jsxGate = resolveJsxGateManifest(authoringRuleUnionStack(result.data as Record<string, unknown>));
+      const jsxGate = resolveJsxGateManifest(result.data as Record<string, unknown>);
       jsxGateNotices = [...jsxGate.notices];
       if (!flags.json) printJsxGateNotices(jsxGateNotices);
       const findings = runAuthoringRules('validate', {
 
@@ -4,8 +4,9 @@
  * The SDUI manifest resolver and the one decision the three authoring commands
  * share about it (#20113). The command-level faces — text and `--json` of `os
  * validate` / `os build` / `os lint`, and their exit statuses — are pinned by
- * `test/jsx-gate-manifest-notice.test.ts`; this file holds the logic those
- * faces all read.
+ * `test/jsx-gate-manifest-notice.e2e.test.ts`, which runs NIGHTLY (it spawns
+ * the CLI). This file is the per-PR guard, so every rule those faces read is
+ * pinned HERE too — the package-carried layout included.
  *
  * ⛔ Anchors, not prose: the notice is found by its `rule` id and asserted on
  * the DATA it must carry (the page count and every place looked), never on the
@@ -23,17 +24,39 @@ import {
   PROJECT_SDUI_MANIFEST_FILE,
   SduiManifestRefusalError,
   countJsxGatePages,
+  jsxGateStacks,
   printJsxGateNotices,
   resolveJsxGateManifest,
   resolveSduiManifest,
   type SduiManifestResolution,
 } from './sdui-manifest.js';
+import { artifactPackages, packageBodyAsStack, runPerPackageAuthoringRules } from './artifact-packages.js';
+import { authoringRuleUnionStack } from './stack-collections.js';
 import { errorCodeFields, isReportedError } from './format.js';
 
 const MANIFEST = { components: { div: { type: 'div', inputs: [{ name: 'children', type: 'slot' }] } } };
 const HTML_STACK = { pages: [{ name: 'landing', kind: 'html', source: '<div>hi</div>' }] };
 const NO_PAGES_STACK = { objects: [{ name: 'ticket' }] };
 
+/** A `kind: 'html'` page the gate checks against a manifest. */
+const html = (name: string) => ({ name, label: name, kind: 'html', source: '<div>hi</div>' });
+/** An ADR-0130 D4 package entry, complete enough for the fold to resolve it. */
+const pkg = (id: string, pages: unknown[]) => ({
+  manifest: { id, name: id.replace(/\W/g, '_'), version: '1.0.0', type: 'app', pages },
+});
+/**
+ * The round-1 layout: the top level carries a `pages` key — so the union fold
+ * keeps it and folds nothing in — while the html pages live only inside
+ * `packages[]`, where the per-package pass still hands them to the gate.
+ */
+const PACKAGE_CARRIED: Record<string, Record<string, unknown>> = {
+  'top-level `pages: []`': { pages: [], packages: [pkg('com.x.site', [html('site_landing')])] },
+  'a top-level kind:full page': {
+    pages: [{ name: 'home', label: 'Home', kind: 'full', regions: [] }],
+    packages: [pkg('com.x.site', [html('site_landing')])],
+  },
+};
+
 const ABSENT: SduiManifestResolution = {
   status: 'absent',
   lookedAt: ['/proj/sdui.manifest.json', CONSOLE_SDUI_MANIFEST_SPECIFIER],
@@ -136,6 +159,59 @@ describe('countJsxGatePages — the pages the JSX gate checks against a manifest
   });
 });
 
+describe('countJsxGatePages — every stack the gate is handed, not the union fold alone', () => {
+  const EMPTY_MANIFEST = { components: {} };
+
+  it.each(Object.entries(PACKAGE_CARRIED))(
+    '%s beside package-carried html pages: the per-package pass judges them, the fold alone judges none',
+    (_label, stack) => {
+      // WHY the fold alone undercounts: it keeps the top-level `pages` key, so
+      // the union run's gate sees no html page at all…
+      expect(validateJsxPages(authoringRuleUnionStack(stack), { manifest: EMPTY_MANIFEST as never })).toEqual([]);
+      // …while the REAL per-package pass hands the package body to the gate —
+      // with a manifest declaring nothing, the page's `div` is flagged there.
+      const perPackage = runPerPackageAuthoringRules({
+        command: 'validate',
+        parsed: stack,
+        unionFindings: [],
+        sduiManifest: EMPTY_MANIFEST,
+      }).findings.filter((f) => f.rule.startsWith('jsx-'));
+      expect(perPackage.length).toBeGreaterThan(0);
+      expect(perPackage.every((f) => f.where.includes('site_landing'))).toBe(true);
+      // So the count follows what is judged: one page.
+      expect(countJsxGatePages(stack)).toBe(1);
+    },
+  );
+
+  it('jsxGateStacks is the fold plus the per-package pass’s OWN enumeration of the bodies', () => {
+    const stack = PACKAGE_CARRIED['top-level `pages: []`'];
+    expect(jsxGateStacks(stack)).toEqual([
+      authoringRuleUnionStack(stack),
+      ...artifactPackages(stack).map((p) => packageBodyAsStack(p.body, stack.packages)),
+    ]);
+    expect(jsxGateStacks(HTML_STACK)).toEqual([HTML_STACK]);
+  });
+
+  it('no double count where both runs see a page: option B (the fold copies the bodies in)', () => {
+    const optionB = { packages: [pkg('com.x.a', [html('a_one')]), pkg('com.x.b', [html('b_one'), html('b_two')])] };
+    expect(jsxGateStacks(optionB)).toHaveLength(3);
+    expect(countJsxGatePages(optionB)).toBe(3);
+  });
+
+  it('no double count where both runs see a page: additive (the top level already IS the union)', () => {
+    const additive = {
+      pages: [html('a_one'), html('b_one')],
+      packages: [pkg('com.x.a', [html('a_one')]), pkg('com.x.b', [html('b_one')])],
+    };
+    expect(countJsxGatePages(additive)).toBe(2);
+  });
+
+  it('an already-folded stack answers the same as the stack it was folded from', () => {
+    const optionB = { packages: [pkg('com.x.a', [html('a_one')])] };
+    expect(countJsxGatePages(authoringRuleUnionStack(optionB))).toBe(countJsxGatePages(optionB));
+  });
+});
+
 describe('resolveJsxGateManifest — one decision, three commands', () => {
   let errSpy: ReturnType<typeof vi.spyOn>;
   beforeEach(() => {
@@ -167,6 +243,24 @@ describe('resolveJsxGateManifest — one decision, three commands', () => {
     expect(n.hint).toContain('/proj/sdui.manifest.json');
   });
 
+  it.each(Object.entries(PACKAGE_CARRIED))(
+    'absent, %s beside package-carried html pages: the notice, counting the package page',
+    (_label, stack) => {
+      const r = resolveJsxGateManifest(stack, ABSENT);
+      expect(r.sduiManifest).toBeUndefined();
+      expect(r.notices).toHaveLength(1);
+      expect(r.notices[0]).toMatchObject({ severity: 'info', rule: JSX_PARSE_LEVEL_ONLY_RULE });
+      expect(r.notices[0].message).toMatch(/^1 /);
+    },
+  );
+
+  it.each(Object.entries(PACKAGE_CARRIED))(
+    'unusable, %s beside package-carried html pages: refused, not waved through',
+    (_label, stack) => {
+      expect(() => resolveJsxGateManifest(stack, UNUSABLE)).toThrow(SduiManifestRefusalError);
+    },
+  );
+
   it('absent with nothing to check: silence is the true answer', () => {
     expect(resolveJsxGateManifest(NO_PAGES_STACK, ABSENT)).toEqual({ sduiManifest: undefined, notices: [] });
     expect(
 
@@ -36,10 +36,18 @@
  *                   TypeError while `{ oops` passed it silently — one rule now
  *                   covers both, with the file and the reason named.
  *
- * Both the notice and the refusal fire only when the stack has a page the JSX
+ * Both the notice and the refusal fire only when the run has a page the JSX
  * gate actually checks. With none, the manifest is read by nothing, so a
  * missing or broken one degrades nothing and silence is the true answer.
  *
+ * "The run" is EVERY stack the gate is handed, not the union fold alone
+ * ({@link jsxGateStacks}). The fold keeps any collection the top level already
+ * carries, `pages: []` included, while the per-package pass still hands each
+ * `packages[]` body to the gate with the same manifest. Counting the fold alone
+ * read 0 for a top-level `pages` key beside package-carried html pages, so that
+ * layout got no notice and a broken manifest passed at exit 0: the silent
+ * degradation this module exists to end, one layout over (#20113 round 1).
+ *
  * ⛔ The console leg's FAILURE semantics are deliberately unchanged: the
  * specifier below resolves to nothing today (the console's `exports` map does
  * not publish that subpath), and whatever makes it reachable owns what a broken
@@ -52,7 +60,9 @@ import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import chalk from 'chalk';
 import type { AuthoringFinding } from '@objectstack/lint';
+import { artifactPackages, packageBodyAsStack } from './artifact-packages.js';
 import { printErrorToStderr, printInfo } from './format.js';
+import { authoringRuleUnionStack } from './stack-collections.js';
 
 /** The file the project provides, looked for in the working directory. */
 export const PROJECT_SDUI_MANIFEST_FILE = 'sdui.manifest.json';
@@ -146,30 +156,69 @@ export function resolveSduiManifest(cwd: string = process.cwd()): SduiManifestRe
 }
 
 /**
- * How many pages the JSX gate checks AGAINST a manifest: `kind: 'html'` (and
- * its deprecated alias `'jsx'`) with a non-empty `source`, over the collection
- * authored either as an array or as a name-keyed map.
+ * Every stack the JSX gate is handed in one run of `os validate` / `os build` /
+ * `os lint`, from the stack the command parsed: the union run's
+ * `authoringRuleUnionStack()` fold, then each `packages[]` body as the
+ * per-package pass judges it — read through that pass's OWN enumeration
+ * (`artifactPackages` + `packageBodyAsStack`), ⛔ never a second walk of
+ * `packages[]`, so the two cannot disagree about which bodies are judged.
+ *
+ * Handed an already-folded stack it answers the same: the fold keeps
+ * `packages`, and re-folding a folded stack returns it by identity.
+ */
+export function jsxGateStacks(stack: AnyRec): AnyRec[] {
+  return [
+    authoringRuleUnionStack(stack),
+    ...artifactPackages(stack).map((pkg) => packageBodyAsStack(pkg.body, stack.packages)),
+  ];
+}
+
+/**
+ * The pages one stack's JSX gate checks AGAINST a manifest: `kind: 'html'`
+ * (and its deprecated alias `'jsx'`) with a non-empty `source`, over the
+ * collection authored either as an array or as a name-keyed map — each keyed
+ * by the name the gate reports it under (`page "NAME"`; a map entry's key when
+ * the entry carries no `name`), or by the record itself when it has neither.
  *
  * The kind set is `validateJsxPages`'s own (`packages/lint/src/
  * validate-jsx-pages.ts`), and the empty-source pages are left out because the
  * gate refuses those with `jsx-page-empty-source` before a manifest is ever
  * consulted. `sdui-manifest.test.ts` holds the two equal by driving the real
  * rule, so a kind the gate starts or stops checking reds there.
- *
- * Hand it the stack the gate judges — the `authoringRuleUnionStack()` fold —
- * so a page that lives only in `packages[]` is counted.
  */
-export function countJsxGatePages(stack: AnyRec): number {
+function checkedPageKeys(stack: AnyRec): unknown[] {
   const pages = stack.pages;
-  const entries: unknown[] = Array.isArray(pages) ? pages : isRecord(pages) ? Object.values(pages) : [];
-  let count = 0;
-  for (const page of entries) {
+  const entries: Array<[string | undefined, unknown]> = Array.isArray(pages)
+    ? pages.map((page): [undefined, unknown] => [undefined, page])
+    : isRecord(pages)
+      ? Object.entries(pages)
+      : [];
+  const keys: unknown[] = [];
+  for (const [mapKey, page] of entries) {
     if (!isRecord(page)) continue;
     if (page.kind !== 'html' && page.kind !== 'jsx') continue;
     if (typeof page.source !== 'string' || page.source.trim() === '') continue;
-    count++;
+    const name = typeof page.name === 'string' && page.name !== '' ? page.name : mapKey;
+    keys.push(name === undefined ? page : `page:${name}`);
+  }
+  return keys;
+}
+
+/**
+ * How many DISTINCT pages the JSX gate checks against a manifest across every
+ * stack it is handed ({@link jsxGateStacks}). Distinct by page name, because a
+ * page reaches the gate twice whenever both runs see it: the fold copies an
+ * absent `pages` in from the bodies, and an additive artifact's top-level
+ * `pages` already IS the union of them. ⚠️ So two packages each shipping a
+ * page under the SAME name count once — a name collision, not a layout this
+ * count is the place to judge.
+ */
+export function countJsxGatePages(stack: AnyRec): number {
+  const seen = new Set<unknown>();
+  for (const judged of jsxGateStacks(stack)) {
+    for (const key of checkedPageKeys(judged)) seen.add(key);
   }
-  return count;
+  return seen.size;
 }
 
 /**
@@ -207,9 +256,12 @@ export interface JsxGateManifest {
 
 /**
  * The one decision the three authoring commands share about the manifest,
- * made once per run over the stack the JSX gate judges. Throws
- * {@link SduiManifestRefusalError} for an `unusable` project manifest when
- * there is a page to check; see the header for the three outcomes.
+ * made once per run. `stack` is the stack the command parsed; the pages
+ * counted are those of every stack the gate is handed ({@link jsxGateStacks}),
+ * so a page carried only inside `packages[]` counts whatever the top level
+ * holds. Throws {@link SduiManifestRefusalError} for an `unusable` project
+ * manifest when there is a page to check; see the header for the three
+ * outcomes.
  */
 export function resolveJsxGateManifest(
   stack: AnyRec,