fix(cli): verify --templates reported a different denominator passing vs failing

The same project, the same run: "11 drift error(s) across 29 template(s)" while
red, "22 template(s) clean" once fixed. Seven templates appear to vanish on the
way to green.

Both numbers were real; neither line named its unit. The failure line divided by
every `template.*` node found — INCLUDING every one the loop `continue`s past,
which on a real project means each project-local template subtype from the
adopter's own provider. The pass line divided by BODIES verified, and an
`@kind: email` template has up to three bodies while being one template. So the
red line took credit for work it had not done, and the two lines could not be
compared with each other.

Both now count templates at least one body of which was actually examined.

Found in the drift-gate demo receipt on the public reference app — the artifact
whose entire purpose is to be checked by a skeptical reader, and the asset the
launch plan names for the Show HN capstone. Every existing assertion matched on a
substring and both phrasings contain "template(s)", so nothing could see it. The
new test asserts the PAIR — same fixture, same number passing and failing —
because the failure half alone was already correct for a single-body template.
Confirmed non-vacuous by reverting the reporting and watching it go red.

cli suite green: 678 pass, 0 fail.

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

Author: dmealing

CHANGELOG.md

@@ -7,6 +7,23 @@ this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+### Fixed — `meta verify --templates` reported a different denominator depending on whether it passed
+
+The same project, the same run: **"11 drift error(s) across 29 template(s)"** while red, and
+**"22 template(s) clean"** once fixed. Seven templates appear to vanish on the way to green.
+Both numbers were real and neither line named its actual unit — the failure line divided by every
+`template.*` node found, **including every one the loop skips** (a subtype it does not check —
+a project-local `template.*` from an adopter's own provider), while the pass line divided by
+**bodies verified** (an `@kind: email` template has up to three and is one template). So the red
+line claimed a denominator of work it had not done, and the two lines could not be compared to
+each other at all. Both now count templates at least one body of which was actually examined.
+
+Found in the drift-gate demo receipt on the public reference app — the artifact whose whole
+purpose is to be checked by a skeptical reader. The existing tests could not see it: every
+assertion matched on a substring, and both phrasings contain the word `template(s)`. The new
+test asserts the **pair** — the same fixture reports the same number passing and failing —
+because the failure half alone was already correct for a single-body template.
+
 ### Fixed — three first-touch defects, found running the quickstart cold on the published `0.24.3`
 
 `0.24.3` made the cold quickstart part of the release procedure. Run against the published

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

@@ -581,7 +581,18 @@ export async function verifyCommand(
 
     let errorCount = 0;
     let warnCount = 0;
-    let checked = 0;
+    // Both report lines below must divide by the SAME thing, and it must be
+    // something that was actually examined. They used to disagree: the failure line
+    // divided by `templates.length` — every node found, INCLUDING every one the loop
+    // `continue`s past (unknown subtype, no renderable body ref) — while the pass
+    // line divided by a count of bodies verified. On a real project the same run read
+    // "11 drift error(s) across 29 template(s)" while failing and "22 template(s)
+    // clean" once fixed: seven templates apparently vanishing on the way to green,
+    // and a failure line claiming a denominator of work that had not been done.
+    // `checkedTemplates` is now the single unit — templates at least one body of
+    // which was verified. (An @kind=email template has up to three bodies and still
+    // counts once; the line says "template(s)", so it counts templates.)
+    let checkedTemplates = 0;
 
     for (const tmpl of templates) {
       // ADR-0039: effective attrs — @payloadRef may be inherited via an abstract template.
@@ -645,6 +656,7 @@ export async function verifyCommand(
       const requiredSlots = promptRules ? attrAsStringArray(tmpl.attr(TEMPLATE_ATTR_REQUIRED_SLOTS)) : [];
       const requiredTags = promptRules ? attrAsStringArray(tmpl.attr(TEMPLATE_ATTR_REQUIRED_TAGS)) : [];
 
+      let anyBodyChecked = false;
       for (const { label, ref } of refs) {
         // Render-engine drift check: mustache variables ↔ payload field names.
         const text = provider.resolve(ref);
@@ -656,7 +668,7 @@ export async function verifyCommand(
           continue;
         }
         const drift = verify(text, fieldTree, { provider, requiredSlots, requiredTags });
-        checked++;
+        anyBodyChecked = true;
         for (const e of drift) {
           if (e.code === ERR_REQUIRED_SLOT_UNUSED) {
             log.warn(`[${tmpl.name}] (${label}) ${e.code}: ${e.path}`);
@@ -667,16 +679,17 @@ export async function verifyCommand(
           }
         }
       }
+      if (anyBodyChecked) checkedTemplates++;
     }
 
     if (errorCount > 0) {
       log.error(
-        `meta verify — ${errorCount} drift error(s) across ${templates.length} template(s).`,
+        `meta verify — ${errorCount} drift error(s) across ${checkedTemplates} template(s).`,
       );
       return 1;
     }
     log.info(
-      `meta verify — ${checked} template(s) clean${warnCount > 0 ? ` (${warnCount} warning(s))` : ""}.`,
+      `meta verify — ${checkedTemplates} template(s) clean${warnCount > 0 ? ` (${warnCount} warning(s))` : ""}.`,
     );
     return 0;
   }

server/typescript/packages/cli/test/integration/verify.test.ts

@@ -178,6 +178,69 @@ describe("meta verify", () => {
     }
   });
 
+  // The two report lines must divide by the SAME thing for the SAME project. They
+  // did not: the pass line counted BODIES verified and the failure line counted every
+  // template NODE found, skipped ones included. An @kind=email template has two or
+  // three bodies and is one template, so it separates the units on its own — and a
+  // real project read "11 drift error(s) across 29 template(s)" while red and
+  // "22 template(s) clean" once green, seven templates apparently vanishing.
+  //
+  // Asserting the PAIR is what makes this non-vacuous: the failure half alone was
+  // already 1 under the old code. (The other half of the old inflation — a template
+  // the loop skips — needs a project-local `template.*` subtype from a provider, the
+  // shape that produced the 29-vs-22 above; core vocabulary requires a body on every
+  // prompt and email, so it cannot be built from core alone.)
+  describe("both report lines divide by the same denominator", () => {
+    function scaffoldEmail(htmlBody: string): string {
+      const tmp = mkdtempSync(join(tmpdir(), "metaobjects-verify-denom-"));
+      mkdirSync(join(tmp, "metaobjects"), { recursive: true });
+      writeFileSync(join(tmp, "metaobjects", "meta.ai.json"), JSON.stringify({
+        "metadata.root": {
+          package: "acme::ai",
+          children: [
+            { "object.value": { name: "P", children: [{ "field.string": { name: "name" } }] } },
+            {
+              // ONE template, TWO renderable bodies — the shape that separates the units.
+              "template.output": {
+                name: "Welcome",
+                "@kind": "email",
+                "@payloadRef": "P",
+                "@subjectRef": "e/subj",
+                "@htmlBodyRef": "e/html",
+              },
+            },
+          ],
+        },
+      }), "utf8");
+      mkdirSync(join(tmp, "prompts", "e"), { recursive: true });
+      writeFileSync(join(tmp, "prompts", "e", "subj"), "Hello {{name}}", "utf8");
+      writeFileSync(join(tmp, "prompts", "e", "html"), htmlBody, "utf8");
+      return tmp;
+    }
+
+    test("counts TEMPLATES, not bodies, when it passes", async () => {
+      const tmp = scaffoldEmail("<p>Hi {{name}}</p>");
+      try {
+        expect(await run(["verify", "--cwd", tmp])).toBe(0);
+        const all = [...out, ...err].join("\n");
+        expect(all).toContain("1 template(s) clean");
+        expect(all).not.toContain("2 template(s) clean");   // two bodies, one template
+      } finally {
+        rmSync(tmp, { recursive: true, force: true });
+      }
+    });
+
+    test("and reports that same 1 when it fails", async () => {
+      const tmp = scaffoldEmail("<p>Hi {{nonExistentField}}</p>");
+      try {
+        expect(await run(["verify", "--cwd", tmp])).toBe(1);
+        expect([...out, ...err].join("\n")).toContain("across 1 template(s)");
+      } finally {
+        rmSync(tmp, { recursive: true, force: true });
+      }
+    });
+  });
+
   test("a custom --prompts dir is honored", async () => {
     const tmp = mkdtempSync(join(tmpdir(), "metaobjects-verify-custom-"));
     mkdirSync(join(tmp, "metaobjects"), { recursive: true });