@@ -0,0 +1,134 @@
+// FR-023 §11.1 item 2 (2026-09-11 qualification) — `Collection.inScope` is
+// `matchesScope(fqn, scope) && (...)`, so declaring `scope.include` narrows
+// the requirements ledger's denominator even for a project with ZERO
+// dependencies — a real behaviour change the CHANGELOG records ("A project
+// that declares scope.include now sees its requirements-ledger denominator
+// narrow to that scope — even with zero dependencies"), and nothing exercised
+// it: `verify-requirements-imported.test.ts` only covers the WITH-a-
+// dependency case (the import-exclusion half of the predicate); this covers
+// the other half — `matchesScope` alone, no dependency involved at all.
+import { describe, test, expect, beforeEach, afterEach, afterAll } from "bun:test";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { run } from "../src/index.js";
+
+/** Two of the project's OWN entities, in different packages — no dependency
+ *  anywhere in this fixture. */
+const APP = JSON.stringify({
+  "metadata.root": {
+    package: "app",
+    children: [
+      {
+        "object.entity": {
+          name: "Order",
+          children: [
+            { "source.rdb": { "@table": "orders" } },
+            { "field.long": { name: "id" } },
+            { "identity.primary": { name: "pk", "@fields": ["id"] } },
+          ],
+        },
+      },
+    ],
+  },
+});
+
+const OTHER = JSON.stringify({
+  "metadata.root": {
+    package: "other",
+    children: [
+      {
+        "object.entity": {
+          name: "Thing",
+          children: [
+            { "source.rdb": { "@table": "things" } },
+            { "field.long": { name: "id" } },
+            { "identity.primary": { name: "pk", "@fields": ["id"] } },
+          ],
+        },
+      },
+    ],
+  },
+});
+
+/** One requirement claiming only `app::Order`. */
+const REQUIREMENTS = JSON.stringify({
+  "metadata.root": {
+    children: [
+      {
+        "requirement.functional": {
+          name: "orderRecord",
+          "@level": 4,
+          "@status": "live",
+          "@statement": "An order is a durable record.",
+          "@counterexample": "An order vanishes on restart.",
+          "@implementedBy": ["app::Order"],
+        },
+      },
+    ],
+  },
+});
+
+const dirs: string[] = [];
+afterAll(() => { for (const d of dirs) rmSync(d, { recursive: true, force: true }); });
+
+/** A project with NO dependencies, optionally declaring `scope.include`. */
+function project(opts: { scopeInclude?: string[] } = {}): string {
+  const root = mkdtempSync(join(tmpdir(), "vreq-scope-nodeps-"));
+  dirs.push(root);
+
+  mkdirSync(join(root, "metaobjects"), { recursive: true });
+  writeFileSync(join(root, "metaobjects", "meta.app.json"), APP, "utf8");
+  writeFileSync(join(root, "metaobjects", "meta.other.json"), OTHER, "utf8");
+  writeFileSync(join(root, "metaobjects", "meta.req.json"), REQUIREMENTS, "utf8");
+
+  const config: Record<string, unknown> = { schema_version: 1, sources: [] };
+  if (opts.scopeInclude) config.scope = { include: opts.scopeInclude };
+  mkdirSync(join(root, ".metaobjects"), { recursive: true });
+  writeFileSync(join(root, ".metaobjects", "config.json"), JSON.stringify(config), "utf8");
+
+  return root;
+}
+
+let out: string[];
+let err: string[];
+let origLog: typeof console.log;
+let origErr: typeof console.error;
+
+beforeEach(() => {
+  out = [];
+  err = [];
+  origLog = console.log;
+  origErr = console.error;
+  console.log = (...a: unknown[]) => { out.push(a.map(String).join(" ")); };
+  console.error = (...a: unknown[]) => { err.push(a.map(String).join(" ")); };
+});
+afterEach(() => {
+  console.log = origLog;
+  console.error = origErr;
+});
+
+describe("meta verify — scope.include narrows the ledger denominator with ZERO dependencies (FR-023)", () => {
+  test("no scope declared: both entities are coverable, only one is claimed", async () => {
+    const root = project();
+    const exit = await run(["verify", "--format", "text", "--cwd", root]);
+    expect(exit).toBe(0);
+
+    const all = [...out, ...err].join("\n");
+    expect(all).toContain("1/2 entities claimed");
+    expect(all).toContain("other::Thing");
+  });
+
+  test("scope.include naming only app:: narrows the denominator to 1/1 — other::Thing drops out entirely", async () => {
+    const root = project({ scopeInclude: ["app::**"] });
+    const exit = await run(["verify", "--format", "text", "--cwd", root]);
+    expect(exit).toBe(0);
+
+    const all = [...out, ...err].join("\n");
+    // Denominator narrows to the declared scope alone — other::Thing is
+    // excluded from the COUNT, not merely reported as unclaimed.
+    expect(all).toContain("1/1 entities claimed");
+    expect(all).not.toContain("other::Thing");
+    expect(all).not.toContain("WARN_REQUIREMENT_OBJECT_UNCLAIMED");
+  });
+});
@@ -0,0 +1,129 @@
+// FR-023 §11.1 item 2 — end-to-end coverage for `src/reference/entity.ts`'s
+// `ctx.select` call site.
+//
+// `src/reference/entity.ts` is not just another generator: it is the literal
+// file `meta init` (ADR-0034 scaffold-and-own) copies into every scaffolded
+// project's `codegen/generators/entity.ts` — the DEFAULT entity-module path
+// every new project runs. Its `generate()` closure reads
+// `ctx.select !== undefined ? { select: ctx.select } : undefined` when
+// rendering the shared-enums module (see the file's own FR-023 comment).
+// `shared-enums-imported.test.ts` already unit-tests the underlying
+// `renderSharedEnumsFile({ select })` primitive directly; nothing exercised
+// the WIRING — that `runGen` threads `opts.scope` through to `ctx.select`
+// and that THIS file's own ternary reads it — end to end. That gap is the
+// same shape as the drift this branch's final gate caught elsewhere: the
+// owned copy diverging from what the built-in path actually does, silently.
+//
+// Two packages, one shared enum, mirroring shared-enums-imported.test.ts's
+// fixture: `lib::Status` (abstract) is used ONLY by `lib::Thing`; `app::Order`
+// carries no enum at all. A `scope` predicate admitting only `app::**`
+// excludes `lib::Thing` — the enum's one consumer — so `enums.ts` must not be
+// emitted. Without a `scope` predicate (undefined), nothing is excluded and
+// `enums.ts` must carry `Status` — proving the ternary's OTHER branch too.
+import { describe, test, expect, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, readdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { MetaDataLoader, InMemoryStringSource } from "@metaobjectsdev/metadata";
+import { runGen, defineConfig } from "../src/index.js";
+import { entityFile as refEntity } from "../src/reference/entity.js";
+
+const LIB = {
+  "metadata.root": {
+    package: "lib",
+    children: [
+      { "field.enum": { name: "Status", abstract: true, "@values": ["a", "b"] } },
+      {
+        "object.entity": {
+          name: "Thing",
+          children: [
+            { "source.rdb": { "@table": "things" } },
+            { "field.long": { name: "id" } },
+            { "field.enum": { name: "status", extends: "lib::Status" } },
+            { "identity.primary": { name: "pk", "@fields": ["id"] } },
+          ],
+        },
+      },
+    ],
+  },
+};
+
+const APP = {
+  "metadata.root": {
+    package: "app",
+    children: [
+      {
+        "object.entity": {
+          name: "Order",
+          children: [
+            { "source.rdb": { "@table": "orders" } },
+            { "field.long": { name: "id" } },
+            { "field.string": { name: "note" } },
+            { "identity.primary": { name: "pk", "@fields": ["id"] } },
+          ],
+        },
+      },
+    ],
+  },
+};
+
+async function loadRoot() {
+  const result = await new MetaDataLoader().load([
+    new InMemoryStringSource(JSON.stringify(LIB)),
+    new InMemoryStringSource(JSON.stringify(APP)),
+  ]);
+  expect(result.errors).toEqual([]);
+  return result.root;
+}
+
+let dirs: string[] = [];
+afterEach(() => {
+  for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });
+});
+
+describe("src/reference/entity.ts — ctx.select call site, end to end via runGen", () => {
+  test("a scope excluding the enum's only consumer suppresses enums.ts entirely", async () => {
+    const root = await loadRoot();
+    const dir = mkdtempSync(join(tmpdir(), "ref-entity-scope-"));
+    dirs.push(dir);
+
+    await runGen({
+      config: defineConfig({
+        outDir: dir,
+        extStyle: "none",
+        dbImport: "~/server/db",
+        dialect: "sqlite",
+        generators: [refEntity()],
+      }),
+      metadata: root,
+      // Admits app::Order only — lib::Thing (the enum's one consumer) is excluded.
+      scope: (fqn: string) => fqn.startsWith("app::"),
+    });
+
+    const files = readdirSync(dir);
+    expect(files).toContain("Order.ts");
+    expect(files).not.toContain("enums.ts");
+  });
+
+  test("with no scope declared, the same shared enum still materializes", async () => {
+    const root = await loadRoot();
+    const dir = mkdtempSync(join(tmpdir(), "ref-entity-noscope-"));
+    dirs.push(dir);
+
+    await runGen({
+      config: defineConfig({
+        outDir: dir,
+        extStyle: "none",
+        dbImport: "~/server/db",
+        dialect: "sqlite",
+        generators: [refEntity()],
+      }),
+      metadata: root,
+      // No `scope` — byte-identical to a project with no scope declared.
+    });
+
+    const files = readdirSync(dir);
+    expect(files).toContain("Order.ts");
+    expect(files).toContain("enums.ts");
+  });
+});