fix(cli): a sub-project generates from its OWN sources, not the ancestor's union (#340)

The gen-side remainder of #326/#327. Once source resolution learned to walk
upward, `meta gen` run in a package whose `metaobjects.config.ts` sits below the
collection root began loading the ancestor's ENTIRE source set. One adopter's web
app went from 376 generated files to 831; the surplus was another module's
server-side LLM prompt payload DTOs, absent from the app's own metadata directory
entirely and types the app will never construct.

It fails OPEN — `tsc --noEmit` passes and the app's tests pass — so the only
symptom is a generated tree that quietly doubled. That is what makes it worth a
gate: anything walking `src/generated` (a barrel, a bundler analysis, a reviewer)
now sees a sibling module's internal vocabulary, and a prompt payload rename shows
up as a diff in the web app's output.

The rule, which is #326's own principle carried to its other half: an ancestor
`.metaobjects/config.json` is the DEFAULT for a package that declares no sources,
never an ADDITION to one that does. `resolveGenCollection` re-resolves the TS
config's directory as a collection in its own right, and it wins only if it
actually resolves metadata. So it can only ever narrow, and only where the shape
could not have worked before:

  - the two configs sit together (every `meta init` project, and every run from a
    project root) — the original collection is returned without a second resolve;
  - the package declares no sources — the pinned resolve throws or comes back
    empty and the ancestor stands, so a package that genuinely lives off an
    ancestor tree is untouched. Gated as its own arm, since narrowing that case
    would re-break #326;
  - the package has its own metadata — it generates from exactly that, which is
    what it did before the upward walk existed.

`verify --codegen` gets the same treatment, and that is not optional: it
regenerates and diffs against the committed output, so narrowing `gen` alone
would make every sub-project report the ancestor's whole contribution as drift —
converting this fix into a broken gate. It re-resolves rather than reusing a
hoisted value because verify's subverbs COMPOSE: `--db` and `--templates` ask
about the whole declared collection, and narrowing the shared root would silently
change what they check.

Deliberately NOT applied to `.metaobjects/` STATE — migrations, snapshots and the
operational block stay keyed on the discovered collection's directory, which #326
settled. This narrows what is LOADED and nothing about where state lives.

Gated by the monorepo shape plus its counter-arm; verified in both directions —
with the fix reverted, the sibling module's entity is emitted into the app's
generated tree and the gate fails.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DhpswkF1NvwxhFWMmdAT15

Author: dmealing

server/typescript/packages/cli/src/commands/gen.ts

@@ -1,7 +1,7 @@
 import { relative } from "node:path";
 import { parseGenArgs } from "../lib/args.js";
 import { resolveGenConfig } from "../lib/config.js";
-import { loadMemoryOptionsFrom, loadMetaobjectsConfig, resolveGenConfigDir } from "../lib/load-metaobjects-config.js";
+import { loadMemoryOptionsFrom, loadMetaobjectsConfig, resolveGenCollection, resolveGenConfigDir } from "../lib/load-metaobjects-config.js";
 import { formatGenResult, formatGenResultToon, type GenFileEntry, type GenFileStatus } from "../lib/output.js";
 import { formatGenResultJson } from "../lib/output-json.js";
 import type { OutputFormat } from "../lib/format.js";
@@ -74,6 +74,12 @@ export async function genCommand(args: string[], cwd: string, fmt: OutputFormat
   // project root's config exactly as before.
   const projectRoot = resolveGenConfigDir(cwd, collection.configDir);
 
+  // ...and a package that declares its own sources GENERATES from them (#340). An
+  // ancestor collection is the default for a package that declares none, never an
+  // addition to one that does — otherwise a sub-project's output silently absorbs
+  // metadata from unrelated trees. Identical object when the two configs sit together.
+  const genCollection = await resolveGenCollection(collection, projectRoot);
+
   // Advisory: nudge to refresh the .claude/skills docs if they predate this CLI.
   // Rooted at `projectRoot`, not ambient cwd — the scaffolded agent context sits
   // with the project that declares the metadata, so a run from a subdirectory
@@ -97,8 +103,8 @@ export async function genCommand(args: string[], cwd: string, fmt: OutputFormat
 
   let metadata;
   try {
-    metadata = await loadMemory(collection.configDir, {
-      files: collection.files,
+    metadata = await loadMemory(genCollection.configDir, {
+      files: genCollection.files,
       ...loadMemoryOptionsFrom(forgeConfig),
     });
   } catch (err) {
@@ -120,7 +126,7 @@ export async function genCommand(args: string[], cwd: string, fmt: OutputFormat
       // GENERATED entities, never over what the collection loads. Always
       // passed: an unconfigured project's predicate admits everything, so this
       // is a no-op for the common case, not a behavior change.
-      scope: collection.inScope,
+      scope: genCollection.inScope,
       ...(cliConfig.entities.length > 0 ? { entityFilter: cliConfig.entities } : {}),
     });
   } catch (err) {

server/typescript/packages/cli/src/commands/verify.ts

@@ -15,7 +15,7 @@ import { warnIfManifestIgnored } from "../lib/manifest-ignored-check.js";
 import { scanSourceForAntiPatterns } from "../lib/anti-patterns.js";
 import { FileProvider } from "../lib/file-provider.js";
 import { derivePayloadFieldTree } from "../lib/payload-field-tree.js";
-import { loadMemoryOptionsFrom, loadMetaobjectsConfig, resolveGenConfigDir } from "../lib/load-metaobjects-config.js";
+import { loadMemoryOptionsFrom, loadMetaobjectsConfig, resolveGenCollection, resolveGenConfigDir } from "../lib/load-metaobjects-config.js";
 import { computeCodegenDrift } from "../lib/codegen-drift.js";
 import { checkRequirements, summariseRequirements } from "../lib/requirement-check.js";
 import { resolveD1Config, resolveMigrateConfig } from "../lib/config.js";
@@ -954,9 +954,33 @@ export async function verifyCommand(
     // question 3) — a `gen` that committed under a narrowed scope and a
     // `verify --codegen` that regenerates unscoped would disagree about which
     // files should exist, reporting every out-of-scope entity as drift.
+    //
+    // The same argument governs the SOURCE SET (#340), and it is the reason this
+    // resolves its own collection instead of reusing the outer one: `gen` in a
+    // sub-project generates from that package's own sources, so a `--codegen` gate
+    // that regenerated from the ancestor's wider set would report every file the
+    // ancestor contributes as drift — turning the #340 fix into a broken gate. It is
+    // re-resolved rather than hoisted because `verify`'s subverbs COMPOSE: `--db` and
+    // `--templates` are answering a question about the whole declared collection, and
+    // narrowing the outer `root` would silently change what they check.
+    const genCollection = await resolveGenCollection(collection, genConfigDir);
+    let codegenRoot = root;
+    if (genCollection !== collection) {
+      try {
+        codegenRoot = await loadMemory(genCollection.configDir, {
+          files: genCollection.files,
+          ...configLoadOptions,
+          strict: !flags.lax,
+        });
+      } catch (err) {
+        log.error(`verify --codegen: failed to load this package's metadata: ${(err as Error).message}`);
+        return 2;
+      }
+    }
+
     let result;
     try {
-      result = await computeCodegenDrift(forgeConfig, root, genConfigDir, collection.inScope);
+      result = await computeCodegenDrift(forgeConfig, codegenRoot, genConfigDir, genCollection.inScope);
     } catch (err) {
       log.error(`verify --codegen: regeneration failed: ${(err as Error).message}`);
       return 1;

server/typescript/packages/cli/src/lib/load-metaobjects-config.ts

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import { randomBytes } from "node:crypto";
 import { createJiti } from "jiti";
 import type { MetaDataTypeProvider, MetaobjectsGenConfig } from "@metaobjectsdev/codegen-ts";
+import { resolveCollection, type Collection } from "@metaobjectsdev/sdk";
 
 const CONFIG_FILE = "metaobjects.config.ts";
 
@@ -212,6 +213,50 @@ export function resolveGenConfigDir(startDir: string, fallback: string): string
   return fallback;
 }
 
+/**
+ * The collection a TypeScript package GENERATES FROM (#340).
+ *
+ * #326/#327 established that the two config files answer different questions, and gave
+ * `metaobjects.config.ts` its own walk. This is the remaining half of the same split:
+ * a sub-project whose TS config sits below the collection root was still LOADING the
+ * ancestor's whole source set, so its `src/generated` absorbed metadata belonging to
+ * unrelated parts of the repository — one adopter's web app went from 376 files to 831,
+ * the surplus being another module's server-side prompt payload DTOs. It fails OPEN
+ * (`tsc` passes, tests pass), so the only symptom is a directory that quietly doubled.
+ *
+ * The rule: an ancestor `.metaobjects/config.json` is the DEFAULT for a package that
+ * declares no sources of its own, never an ADDITION to one that does. So when the TS
+ * config sits somewhere the collection did not, that directory is re-resolved as a
+ * collection in its own right, and it wins if it actually resolves any metadata.
+ *
+ * It can only ever NARROW, and only in a shape that could not have worked before:
+ *   - the two directories coincide (every `meta init` project, and every run from a
+ *     project root) — returns the original, untouched, without a second resolve;
+ *   - the sub-project declares no sources — the pinned resolve throws
+ *     `ERR_SOURCE_UNRESOLVED` or comes back empty, and the ancestor stands, so a
+ *     package that genuinely lives off an ancestor tree keeps working;
+ *   - the sub-project has its own metadata — it generates from exactly that, which is
+ *     what it did before source resolution learned to walk upward.
+ *
+ * Deliberately NOT applied to `.metaobjects/` STATE. Migrations, snapshots and the
+ * operational block stay keyed on the discovered collection's directory (#326 settled
+ * that); this narrows what is LOADED, and nothing about where state lives.
+ */
+export async function resolveGenCollection(
+  collection: Collection,
+  genConfigDir: string,
+): Promise<Collection> {
+  if (resolve(genConfigDir) === resolve(collection.configDir)) return collection;
+  try {
+    const pinned = await resolveCollection(genConfigDir, { explicitDir: genConfigDir });
+    return pinned.files.length > 0 ? pinned : collection;
+  } catch {
+    // The sub-project declares nothing resolvable of its own — inherit, exactly as a
+    // package with no config always has.
+    return collection;
+  }
+}
+
 export async function loadMetaobjectsConfig(projectRoot: string): Promise<MetaobjectsGenConfig> {
   const fullPath = resolve(projectRoot, CONFIG_FILE);
   if (!existsSync(fullPath)) {

server/typescript/packages/cli/test/integration/gen-subproject-source-scope.test.ts

@@ -0,0 +1,129 @@
+/**
+ * #340 — a sub-project GENERATES from its own sources, not from the union of every
+ * tree an ancestor `.metaobjects/config.json` declares.
+ *
+ * The gen-side remainder of #326/#327. Once source resolution learned to walk upward,
+ * a package whose `metaobjects.config.ts` sits below the collection root began loading
+ * the ancestor's entire source set: one adopter's web app went from 376 generated
+ * files to 831, the surplus being another module's server-side prompt payload DTOs
+ * that the app will never construct. It fails OPEN — `tsc` passes, tests pass — so the
+ * only symptom is a directory that quietly doubled, which is why it needs a gate
+ * rather than a reader.
+ *
+ * The rule under test: an ancestor collection is the DEFAULT for a package that
+ * declares no sources, never an ADDITION to one that does. Both arms matter — the
+ * second is what keeps a package that legitimately lives off an ancestor tree working.
+ */
+import { describe, test, expect } from "bun:test";
+import { cpSync, mkdtempSync, mkdirSync, rmSync, existsSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { run } from "../../src/index.js";
+
+const FIXTURES = resolve(import.meta.dirname, "../fixtures");
+// Temp dirs live inside the monorepo so jiti can resolve @metaobjectsdev/* when it
+// loads metaobjects.config.ts (same rationale as gen-nested-gen-config.test.ts).
+const WORKSPACE_TMP = resolve(import.meta.dirname, "../fixtures/__tmp__");
+
+function genConfigBody(outDir: string): string {
+  return `
+import { defineConfig } from "@metaobjectsdev/codegen-ts";
+import { entityFile } from "@metaobjectsdev/codegen-ts/generators";
+export default defineConfig({
+  outDir: ${JSON.stringify(outDir)},
+  dialect: "sqlite",
+  dbImport: "~/db",
+  extStyle: "none",
+  generators: [entityFile()],
+});
+`;
+}
+
+/** An entity that exists ONLY in the unrelated tree, so its output is unambiguous. */
+const OTHER_TREE_ENTITY = JSON.stringify({
+  "metadata.root": {
+    package: "other",
+    children: [
+      {
+        "object.entity": {
+          name: "AbilityGenerationPayload",
+          children: [
+            { "source.rdb": { "@table": "ability_generation_payloads" } },
+            { "field.uuid": { name: "id" } },
+            { "identity.primary": { name: "id", "@fields": "id", "@generation": "uuid" } },
+          ],
+        },
+      },
+    ],
+  },
+});
+
+describe("meta gen — a sub-project's own sources govern its output (#340)", () => {
+  test("does NOT absorb an unrelated tree the ancestor collection also declares", async () => {
+    mkdirSync(WORKSPACE_TMP, { recursive: true });
+    const root = mkdtempSync(join(WORKSPACE_TMP, "forge-gen-subscope-"));
+    try {
+      // The app: its own metadata AND its own TS config.
+      const app = join(root, "app");
+      mkdirSync(app, { recursive: true });
+      cpSync(join(FIXTURES, "trainer-website-meta"), app, { recursive: true });
+      const outDir = join(app, "generated", "db");
+      writeFileSync(join(app, "metaobjects.config.ts"), genConfigBody(outDir));
+
+      // A sibling module's tree, which has no business in the app's output.
+      mkdirSync(join(root, "other", "metaobjects"), { recursive: true });
+      writeFileSync(join(root, "other", "metaobjects", "meta.other.json"), OTHER_TREE_ENTITY, "utf8");
+
+      // The repo root declares BOTH — the port-neutral "where does metadata live"
+      // answer for a polyglot monorepo, which is exactly what it is for.
+      mkdirSync(join(root, ".metaobjects"), { recursive: true });
+      writeFileSync(
+        join(root, ".metaobjects", "config.json"),
+        JSON.stringify({
+          schema_version: 1,
+          sources: [{ path: "app/metaobjects" }, { path: "other/metaobjects" }],
+        }),
+        "utf8",
+      );
+
+      const exit = await run(["gen", "--cwd", app]);
+      expect(exit).toBe(0);
+      // The app's own entity is generated, as always.
+      expect(existsSync(join(outDir, "User.ts"))).toBe(true);
+      // ...and the sibling module's is not. Before the fix this file was emitted
+      // into the app's generated tree.
+      expect(existsSync(join(outDir, "AbilityGenerationPayload.ts"))).toBe(false);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  // The counter-arm. Narrowing must never strand a package that has no sources of its
+  // own — for that one, the ancestor collection is still the answer, and #326's shape
+  // (a TS config below a collection root) is precisely that package.
+  test("a sub-project with NO sources of its own still inherits the ancestor's", async () => {
+    mkdirSync(WORKSPACE_TMP, { recursive: true });
+    const root = mkdtempSync(join(WORKSPACE_TMP, "forge-gen-subscope-inherit-"));
+    try {
+      // All metadata lives at the root, in a tree the app does not contain.
+      cpSync(join(FIXTURES, "trainer-website-meta"), join(root, "shared"), { recursive: true });
+      mkdirSync(join(root, ".metaobjects"), { recursive: true });
+      writeFileSync(
+        join(root, ".metaobjects", "config.json"),
+        JSON.stringify({ schema_version: 1, sources: [{ path: "shared/metaobjects" }] }),
+        "utf8",
+      );
+
+      // The app carries a TS config and nothing else.
+      const app = join(root, "app");
+      mkdirSync(app, { recursive: true });
+      const outDir = join(app, "generated", "db");
+      writeFileSync(join(app, "metaobjects.config.ts"), genConfigBody(outDir));
+
+      const exit = await run(["gen", "--cwd", app]);
+      expect(exit).toBe(0);
+      expect(existsSync(join(outDir, "User.ts"))).toBe(true);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});