test(cli): measure the parse-check layer through a name that reaches it

The #16726 charset gate answers first for `foo.bar`, so #16541's pin now
measures its own subject through `class` — inside the charset, refused by the
compiler — and keeps every `foo.bar` assertion that is still about the command.

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

Author: claude

packages/cli/src/commands/generate.ts

@@ -760,7 +760,14 @@ async function runMetadataGeneration(type: string, name: string, flags: { dir?:
         '  write and the name that lands in the file are always the same string.',
       ));
       console.log(chalk.dim(
-        `  Nothing was written. Try \`${CLI_ALIAS} g ${type} order_line\` or \`${CLI_ALIAS} g ${type} customer\`.`,
+        // ⛔ The examples are deliberately NOT built from what the author
+        // typed. A suggestion derived from the refused name is option (B)
+        // wearing a prompt: the author accepts it, and the divergence this
+        // gate exists to prevent arrives one keystroke later.
+        `  Nothing was written. Names like \`${CLI_ALIAS} g ${type} customer\` or`,
+      ));
+      console.log(chalk.dim(
+        `  \`${CLI_ALIAS} g ${type} sales_order\` are accepted.`,
       ));
       console.log('');
       process.exit(1);

packages/cli/test/generate-refuses-name-outside-charset.test.ts

@@ -240,9 +240,13 @@ describe('[#16726] the gate and #16541`s parse check are DISTINCT layers', () =>
     expect(failures.length).toBeGreaterThan(0);
     expect(backstop.code).toBe(1);
     expect(backstop.stdout).toContain('does not parse');
-    // ⛔ The gate must not have shadowed it: the author gets the compiler's
-    // reason, which is the specific one.
-    expect(backstop.stdout).toContain("',' expected.");
+    // ⛔ The gate must not have shadowed it: the author gets the COMPILER's
+    // reason, and the compiler's reason for this name is specific to it —
+    // a hand-written "invalid name" line would satisfy every other
+    // assertion in this block.
+    expect(backstop.stdout).toContain("'class' is not allowed as a variable declaration name.");
+    // ⛔ And it is NOT the charset refusal: `class` is inside the charset.
+    expect(backstop.stdout).not.toContain('must match pattern');
   });
 
   it('⚠️ records what the pair actually does with `os generate view class`', () => {

packages/cli/test/generate-refuses-unparseable-name.test.ts

@@ -31,6 +31,31 @@
  * `integration` (behaviour)"), and ⛔ nothing is renamed to make the two cuts
  * agree.
  *
+ * ## ⚠️ WHICH NAME REACHES THIS CHECK CHANGED (#16726)
+ *
+ * A charset gate now sits in FRONT of this one: a name outside the charset
+ * `packages/spec` declares for an object `name` is refused before anything is
+ * derived from it, so it never reaches the compiler at all. `foo.bar` — the
+ * card's measured name — is one of those, and it still exits 1 having written
+ * nothing, which is the defect #16541 was filed about. What it no longer
+ * demonstrates is THIS check: the refusal it now meets is the gate's.
+ *
+ * So the parse check is measured through `class`, added here for that purpose.
+ * It is inside the charset (every character is a lowercase letter), the gate
+ * admits it, and `const class:` is still not a declaration — so it is the name
+ * that proves this command consults the compiler before it writes, and that
+ * the layer in front did not swallow the layer behind. ⛔ Nothing was deleted
+ * to make room for it: every `foo.bar` assertion that is still about the
+ * COMMAND (exit code, no rewrite, nothing on disk) is asserted below unchanged.
+ *
+ * One property genuinely stopped being reachable from here: a name that breaks
+ * the BARREL line as well as the scaffold. A reserved word is legal as an
+ * `export { default as … }` alias, so no charset-legal name breaks both, and
+ * every name that does is now stopped one layer earlier. That half stays
+ * pinned where it still runs — `generate-emission-parses.test.ts`'s CANARY row
+ * measures `foo.bar` against both emissions, with the instrument this command
+ * calls.
+ *
  * ## The control is load-bearing
  *
  * A refusal that fires on everything would satisfy every assertion about
@@ -115,28 +140,34 @@ function parseErrors(source: string): string[] {
 let refusedDir: string;
 let controlDir: string;
 let dryRunDir: string;
+let unparseableDir: string;
 
 let refused: Run;
 let refusedAgain: Run;
 let control: Run;
 let dryRun: Run;
+let unparseable: Run;
 
 beforeAll(async () => {
   refusedDir = mkdtempSync(join(tmpdir(), 'os-g-refuse-'));
   controlDir = mkdtempSync(join(tmpdir(), 'os-g-control-'));
   dryRunDir = mkdtempSync(join(tmpdir(), 'os-g-dryrun-'));
+  unparseableDir = mkdtempSync(join(tmpdir(), 'os-g-unparseable-'));
 
   // Sequential on purpose: cold tsx starts, each loading every command module,
   // in a container several agents share.
   refused = await runTsx([CLI, 'generate', 'object', 'foo.bar'], refusedDir);
   // A second generator, to show the refusal is not one patched call site.
   refusedAgain = await runTsx([CLI, 'generate', 'flow', 'foo.bar'], refusedDir);
   dryRun = await runTsx([CLI, 'generate', 'object', 'foo.bar', '--dry-run'], dryRunDir);
+  // Inside the charset, outside the grammar — the name that reaches THIS
+  // check now that a charset gate stands in front of it (#16726).
+  unparseable = await runTsx([CLI, 'generate', 'object', 'class'], unparseableDir);
   control = await runTsx([CLI, 'generate', 'object', 'order_line'], controlDir);
 }, RUN_TIMEOUT_MS);
 
 afterAll(() => {
-  for (const dir of [refusedDir, controlDir, dryRunDir]) {
+  for (const dir of [refusedDir, controlDir, dryRunDir, unparseableDir]) {
     rmSync(dir, { recursive: true, force: true });
   }
 });
@@ -147,21 +178,9 @@ describe('[#16541] `os generate object foo.bar` refuses instead of exiting 0', (
     expect(refused.code).toBe(1);
   });
 
-  it('says it is refusing, and says the emission does not parse', () => {
+  it('says it is refusing, and names the value it refused', () => {
     expect(refused.stdout).toContain('Refusing to generate');
-    expect(refused.stdout).toContain('does not parse');
-  });
-
-  it('names BOTH files the name would have corrupted', () => {
-    expect(refused.stdout).toContain('foo.bar.object.ts');
-    expect(refused.stdout).toContain('index.ts');
-  });
-
-  it('quotes the compiler`s own diagnostic rather than a restatement of it', () => {
-    // The message TypeScript emits for a property access in a binding
-    // position. Asserted because a hand-written "invalid name" line would pass
-    // every other assertion in this block.
-    expect(refused.stdout).toContain("',' expected.");
+    expect(refused.stdout).toContain('foo.bar');
   });
 
   it('⛔ does not rewrite the name into a legal-looking identifier', () => {
@@ -178,6 +197,33 @@ describe('[#16541] `os generate object foo.bar` refuses instead of exiting 0', (
   });
 });
 
+describe('[#16541] the parse check still refuses, with the compiler`s own words', () => {
+  // `class`, not `foo.bar` — see the header. Everything asserted here is what
+  // #16541 asserted about `foo.bar` before the #16726 gate started answering
+  // for that spelling first.
+  it('exits non-zero and says the emission does not parse', () => {
+    expect(unparseable.code).toBe(1);
+    expect(unparseable.stdout).toContain('Refusing to generate');
+    expect(unparseable.stdout).toContain('does not parse');
+  });
+
+  it('names the file the name would have corrupted', () => {
+    expect(unparseable.stdout).toContain('class.object.ts');
+  });
+
+  it('quotes the compiler`s own diagnostic rather than a restatement of it', () => {
+    // The message TypeScript emits for a reserved word in a binding position.
+    // Asserted because a hand-written "invalid name" line would pass every
+    // other assertion in this block — and because it proves the gate in front
+    // did not answer for this name.
+    expect(unparseable.stdout).toContain("'class' is not allowed as a variable declaration name.");
+  });
+
+  it('writes nothing', () => {
+    expect(existsSync(join(unparseableDir, 'src'))).toBe(false);
+  });
+});
+
 describe('[#16541] the refusal is one chokepoint, not one patched generator', () => {
   it('`os generate flow foo.bar` is refused the same way', () => {
     expect(refusedAgain.code).toBe(1);