test(cli): pin the language-field failures beside the recipe that claims them

A comment here pointed at a `the language field` suite that did not exist on
this branch — it was added one PR up the stack, so a maintainer following
the pointer found nothing and might have assumed the C#-abort and
wrong-parser behaviours were covered. Reported in review, and correct.

Moved down rather than the comment softened. `route.txt` makes both claims
on this branch, and the house rule is that an engine claim in a recipe is
quoted from a pinned binary rather than described, so the claim and its pin
belong in the same change.

Adds a third case while here, pinning the fact this branch's own history
got wrong: `C++` and `cpp` are ACCEPTED aliases resolving to Cpp, so an
off-list spelling is not reliably an error. Without it the suite reads as
"off-list spellings fail", which is the claim that had to be corrected.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cyga14bww8rmazH2XrF8ms

Author: theCodeDrift

packages/cli/test/ast-grep-vendor-contract.test.ts

@@ -153,6 +153,10 @@ const test = (cwd: string, ruleId: string) =>
 /** One eval call, at line 0 column 10 of `src/a.ts`. */
 const evalSource = { "src/a.ts": 'const x = eval("1");\n' };
 
+/** `rule("no-eval")` with its `language:` swapped for another spelling. */
+const atLanguage = (language: string) =>
+  rule("no-eval").replace("language: TypeScript", `language: ${language}`);
+
 /** Exit status of scanning one finding declared at `severity`. */
 const statusAt = (severity: string) =>
   scan(
@@ -484,6 +488,65 @@ withSg("ast-grep vendor contract", () => {
     });
   });
 
+  /**
+   * How a wrong `language:` fails — the two shapes `route.txt` warns about.
+   *
+   * Nothing of ours catches either one first: the vendored
+   * `src/generated/ast-grep-rule-schema.json` types `$defs.Language` as a bare
+   * string with no enum, and `verify` never reads the field. So the binary's
+   * response IS the contract, and a recipe telling an author what to expect is
+   * quoting it. These live beside the recipe that makes the claim, so the claim
+   * and its pin land in the same change.
+   */
+  describe("the language field", () => {
+    it("fails the whole scan on a spelling it does not recognize", () => {
+      // `C#` is the plausible wrong spelling of `CSharp`, and getting it wrong
+      // is not a rule that quietly matches nothing: ast-grep cannot parse the
+      // config, so every OTHER rule in the project goes unreported too. The
+      // error names the enum, which is what an author sees.
+      const result = scan(
+        project({ rules: { "no-eval": atLanguage("C#") }, sources: evalSource })
+      );
+      expect(result.status).toBeGreaterThan(1);
+      expect(result.stderr).toContain("SgLang");
+    });
+
+    it("accepts off-list aliases, so an off-list spelling is not an error", () => {
+      // The half that corrects an earlier claim in this branch's own history:
+      // `C++` and `cpp` are NOT rejected, they resolve to Cpp. The recipe tells
+      // authors to copy from the canonical list for the other two reasons, not
+      // because every off-list spelling fails.
+      const sources = {
+        "src/a.cpp": "int main(){int simply=1;return simply;}\n",
+      };
+      for (const spelling of ["Cpp", "C++", "cpp"]) {
+        const result = scan(
+          project({ rules: { "no-eval": atLanguage(spelling) }, sources })
+        );
+        expect(result.status, `${spelling} was rejected`).not.toBeGreaterThan(
+          1
+        );
+      }
+    });
+
+    it("treats Tsx and TypeScript as different parsers, not aliases", () => {
+      // The quiet half of the same field, and the reason the recipe names this
+      // pair specifically. `TypeScript` over a `.tsx` tree exits clean with no
+      // findings, which is indistinguishable from a codebase with nothing to
+      // flag — the rule looks written and proves nothing.
+      const sources = { "src/a.tsx": "const el = <div>{eval(x)}</div>;\n" };
+      const asTypeScript = scan(
+        project({ rules: { "no-eval": atLanguage("TypeScript") }, sources })
+      );
+      expect(asTypeScript.status).toBe(0);
+      expect(asTypeScript.stdout.trim()).toBe("");
+      expect(
+        scan(project({ rules: { "no-eval": atLanguage("Tsx") }, sources }))
+          .stdout
+      ).toContain("eval(x)");
+    });
+  });
+
   /**
    * Relocated from `engine-layout.test.ts`, which existed only for these two.
    *