fix(cli): count a fixture only when the file's own id is this rule

Three review findings on #156, all in the same shape: a claim stated
twice diverges, and the second copy is the one nobody reads.

`fixtureCoverage` counted a test file by filename alone, while
`sg test --filter ^<id>$` resolves cases against the file's `id:`
field. A draft copied from another rule — right filename, wrong `id:` —
had its buckets counted toward coverage while ast-grep never ran them,
reopening the "never shown to fire" gap this branch exists to close
through the filename door rather than the empty-bucket one.

The "what counts as this rule's test file" predicate was also written
twice in one `verifyRule()` pass. It now lives in one
`discoverRuleTestFiles` used by both `validateRequirements` and
`fixtureCoverage`.

Also drops the duplicate `describe("the language field")` suite that the
rebase left behind. The base branch carries the fuller three-test
version; commit 44f4850 removed the duplicate `atLanguage` helper but
missed the suite itself.

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

Author: theCodeDrift

packages/cli/src/rules/verify.ts

@@ -165,17 +165,8 @@ async function validateRequirements(
     }
   }
 
-  // A rule's tests live inside the rule directory, so there is one place to
-  // look and no resolution order to get wrong.
-  let hasTestFile = false;
-  try {
-    const entries = await readdir(ruleTestsDirectory(cwd, "sg", ruleId));
-    hasTestFile = entries.some(
-      (f) => f.startsWith(`${ruleId}-`) && f.endsWith("-test.yml")
-    );
-  } catch {
-    // No tests directory — hasTestFile stays false.
-  }
+  const testFiles = await discoverRuleTestFiles(cwd, ruleId);
+  const hasTestFile = testFiles.length > 0;
   if (!hasTestFile) {
     errors.push(
       `No test file found for rule "${ruleId}" in ` +
@@ -186,6 +177,39 @@ async function validateRequirements(
   return { valid: errors.length === 0, errors, hasTestFile };
 }
 
+/**
+ * Every file in a rule's own `.tests/` directory that the naming convention
+ * claims for this rule, as absolute paths.
+ *
+ * A rule's tests live inside the rule directory, so there is one place to look
+ * and no resolution order to get wrong. Stated once because two callers ask the
+ * same question in the same `verifyRule()` pass — `validateRequirements` for
+ * "are there any tests at all", `fixtureCoverage` for "what is in them" — and a
+ * change to the convention has to move both at once or they disagree.
+ *
+ * The filename is all this decides. What ast-grep will actually RUN is keyed on
+ * the file's own `id:` field, which is a separate question, asked where it
+ * matters (see {@link fixtureCoverage}).
+ */
+async function discoverRuleTestFiles(
+  cwd: string,
+  ruleId: string
+): Promise<string[]> {
+  const directory = ruleTestsDirectory(cwd, "sg", ruleId);
+  let entries: string[];
+  try {
+    entries = await readdir(directory);
+  } catch {
+    // No tests directory — the rule owns no test files.
+    return [];
+  }
+  return entries
+    .filter(
+      (entry) => entry.startsWith(`${ruleId}-`) && entry.endsWith("-test.yml")
+    )
+    .map((entry) => join(directory, entry));
+}
+
 /** Classify a rule's buckets by how many sources each held. */
 function coverageOf(
   validCount: number,
@@ -209,28 +233,25 @@ function coverageOf(
  * A file that cannot be read or parsed contributes nothing. `sg test` reports
  * malformed test YAML itself, and guessing at a bucket count from a file we
  * could not parse would be a worse error than the one already being raised.
+ *
+ * Only a file whose own `id:` is this rule counts, which is a stricter test
+ * than the filename it was found by. `sg test --filter ^<id>$` resolves cases
+ * against that field, so a file named for `no-eval` but carrying
+ * `id: no-alert-scratch` — a draft copied from another rule — is never executed
+ * for `no-eval`. Counting its buckets here would report coverage for fixtures
+ * that never ran, which is the same "never shown to fire" gap this check
+ * exists to close, reached through the filename rather than an empty bucket.
  */
 async function fixtureCoverage(
   cwd: string,
   ruleId: string
 ): Promise<SgFixtureCoverage> {
-  const directory = ruleTestsDirectory(cwd, "sg", ruleId);
-  let entries: string[];
-  try {
-    entries = await readdir(directory);
-  } catch {
-    return "none";
-  }
-
   let validCount = 0;
   let invalidCount = 0;
-  for (const entry of entries) {
-    if (!entry.startsWith(`${ruleId}-`) || !entry.endsWith("-test.yml")) {
-      continue;
-    }
+  for (const file of await discoverRuleTestFiles(cwd, ruleId)) {
     let parsed: unknown;
     try {
-      parsed = parse(await readFile(join(directory, entry), "utf8"));
+      parsed = parse(await readFile(file, "utf8"));
     } catch {
       continue;
     }
@@ -242,6 +263,7 @@ async function fixtureCoverage(
       continue;
     }
     const buckets = parsed as Record<string, unknown>;
+    if (buckets.id !== ruleId) continue;
     if (Array.isArray(buckets.valid)) validCount += buckets.valid.length;
     if (Array.isArray(buckets.invalid)) invalidCount += buckets.invalid.length;
   }

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

@@ -655,47 +655,6 @@ withSg("ast-grep vendor contract", () => {
     });
   });
 
-  /**
-   * How a wrong `language:` fails — the two shapes `create-sg-rule.txt` warns
-   * about where the field is written.
-   *
-   * 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.
-   */
-  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("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.
    *

packages/cli/test/verify.test.ts

@@ -461,6 +461,31 @@ describe("verifyRule", () => {
       expect(result.tests.fixtures).toBe("both");
       expect(result.tests.valid).toBe(true);
     });
+
+    it("ignores a file in the rule's directory whose own id is another rule", async () => {
+      // The filename says `no-eval`, the `id:` inside says otherwise — the
+      // shape a draft copied from another rule arrives in. `sg test --filter
+      // ^no-eval$` resolves cases against that `id:`, so these fixtures never
+      // run; counting them would report coverage the rule never earned.
+      await coverageProject(temporaryDirectory, { valid: ["const x = 1;"] });
+      await writeFile(
+        join(
+          temporaryDirectory,
+          ".taskless",
+          "sg",
+          "rule-tests",
+          "no-eval-20260331-test.yml"
+        ),
+        stringify({
+          id: "no-alert-scratch",
+          invalid: ["eval('alert(1)')"],
+        }),
+        "utf8"
+      );
+      const result = await verifyRule(temporaryDirectory, "no-eval");
+      expect(result.tests.fixtures).toBe("valid-only");
+      expect(result.tests.valid).toBe(false);
+    });
   });
 });