From 67c3865a797d3eed7570eccd518bb7cb9799bf93 Mon Sep 17 00:00:00 2001
From: Abhitej John <aajohn@microsoft.com>
Date: Fri, 17 Jul 2026 16:36:41 -0700
Subject: [PATCH] Add eval-review skill/eval quality checker
 (eng/vally-graders)

Adds a standalone, repo-local checker that reviews skill+eval quality
before merge: four free static graders (eval-deleading, assertion-hardening,
meta-commentary, negative-scenario) plus one opt-in real-model LLM grader
(eval-review) for the judgment dimensions. Enforcement runs via the
review.mjs runner, gated on PRs as free static-only steps in the existing
skill-check.yml check job (changed units only). The graders are also exported
as Vally-compatible Grader objects via registerGraders for future use; Vally
does not currently enforce custom graders (documented, not a regression).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 365dd5fb-86a9-4628-9b14-7e6ec7053072
---
 .github/workflows/skill-check.yml             |  43 ++
 eng/vally-graders/README.md                   | 205 +++++++++
 .../graders/assertion-hardening.mjs           | 187 +++++++++
 eng/vally-graders/graders/eval-deleading.mjs  | 181 ++++++++
 eng/vally-graders/graders/eval-review.mjs     | 394 ++++++++++++++++++
 eng/vally-graders/graders/meta-commentary.mjs | 118 ++++++
 .../graders/negative-scenario.mjs             | 101 +++++
 eng/vally-graders/index.mjs                   |  55 +++
 eng/vally-graders/lib/grader-base.mjs         |  65 +++
 eng/vally-graders/lib/llm-client.mjs          | 174 ++++++++
 eng/vally-graders/lib/locate.mjs              | 324 ++++++++++++++
 eng/vally-graders/lib/report.mjs              | 128 ++++++
 eng/vally-graders/package-lock.json           | 247 +++++++++++
 eng/vally-graders/package.json                |  27 ++
 eng/vally-graders/review.mjs                  | 279 +++++++++++++
 .../plugins/demo/skills/clean-skill/SKILL.md  |  13 +
 .../plugins/demo/skills/leaky-skill/SKILL.md  |  15 +
 .../repo/tests/demo/clean-skill/eval.yaml     |  25 ++
 .../tests/demo/clean-skill/fixtures/Thing.cs  |   6 +
 .../repo/tests/demo/leaky-skill/eval.yaml     |  14 +
 .../leaky-skill/fixtures/WidgetProcessor.cs   |   5 +
 eng/vally-graders/tests/graders.test.mjs      | 368 ++++++++++++++++
 22 files changed, 2974 insertions(+)
 create mode 100644 eng/vally-graders/README.md
 create mode 100644 eng/vally-graders/graders/assertion-hardening.mjs
 create mode 100644 eng/vally-graders/graders/eval-deleading.mjs
 create mode 100644 eng/vally-graders/graders/eval-review.mjs
 create mode 100644 eng/vally-graders/graders/meta-commentary.mjs
 create mode 100644 eng/vally-graders/graders/negative-scenario.mjs
 create mode 100644 eng/vally-graders/index.mjs
 create mode 100644 eng/vally-graders/lib/grader-base.mjs
 create mode 100644 eng/vally-graders/lib/llm-client.mjs
 create mode 100644 eng/vally-graders/lib/locate.mjs
 create mode 100644 eng/vally-graders/lib/report.mjs
 create mode 100644 eng/vally-graders/package-lock.json
 create mode 100644 eng/vally-graders/package.json
 create mode 100644 eng/vally-graders/review.mjs
 create mode 100644 eng/vally-graders/tests/fixtures/repo/plugins/demo/skills/clean-skill/SKILL.md
 create mode 100644 eng/vally-graders/tests/fixtures/repo/plugins/demo/skills/leaky-skill/SKILL.md
 create mode 100644 eng/vally-graders/tests/fixtures/repo/tests/demo/clean-skill/eval.yaml
 create mode 100644 eng/vally-graders/tests/fixtures/repo/tests/demo/clean-skill/fixtures/Thing.cs
 create mode 100644 eng/vally-graders/tests/fixtures/repo/tests/demo/leaky-skill/eval.yaml
 create mode 100644 eng/vally-graders/tests/fixtures/repo/tests/demo/leaky-skill/fixtures/WidgetProcessor.cs
 create mode 100644 eng/vally-graders/tests/graders.test.mjs

diff --git a/.github/workflows/skill-check.yml b/.github/workflows/skill-check.yml
index c444826777..7d11c6393f 100644
--- a/.github/workflows/skill-check.yml
+++ b/.github/workflows/skill-check.yml
@@ -17,6 +17,8 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
+          # Full history so eval-review can diff against the PR base ref.
+          fetch-depth: 0
           persist-credentials: false
 
       - name: Cache validator archive
@@ -54,3 +56,44 @@ jobs:
             --allowed-external-deps eng/allowed-external-deps.txt \
             --known-domains eng/known-domains.txt
 
+      # -----------------------------------------------------------------------
+      # eval-review: free, no-model quality gate for skill+eval units, run as
+      # steps in this same job (no separate workflow).
+      #
+      # Enforcement runs via the standalone runner (eng/vally-graders/review.mjs),
+      # NOT via Vally: `vally lint --grader-plugin` does not execute custom static
+      # graders against skills, and `vally experiment run` (this repo's eval path)
+      # can't load grader plugins. See eng/vally-graders/README.md.
+      #
+      # Static-only and free: the paid, opt-in LLM grader (review.mjs --llm) is
+      # deliberately NOT run here. assertion-hardening and meta-commentary block;
+      # the noisier eval-deleading / negative-scenario dimensions are report-only
+      # (dimension ratchet — tighten by dropping --report-only as the backlog is
+      # burned down). Only PR-touched units are evaluated (changed-files default);
+      # set EVAL_REVIEW_ALL=1 to scan every unit (manual/nightly run-all path).
+      # -----------------------------------------------------------------------
+      - name: Setup Node.js
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: 22
+
+      - name: Install eval-review dependencies
+        working-directory: eng/vally-graders
+        run: npm ci --omit=optional
+
+      - name: Unit-test the graders
+        working-directory: eng/vally-graders
+        run: npm test
+
+      - name: Run eval-review gate
+        run: |
+          if [ "${EVAL_REVIEW_ALL:-}" = "1" ]; then
+            scope="--all"
+          else
+            scope="--base origin/${{ github.base_ref }}"
+          fi
+          node eng/vally-graders/review.mjs \
+            $scope \
+            --report-only eval-deleading \
+            --report-only negative-scenario
+
diff --git a/eng/vally-graders/README.md b/eng/vally-graders/README.md
new file mode 100644
index 0000000000..d1bf15a0fb
--- /dev/null
+++ b/eng/vally-graders/README.md
@@ -0,0 +1,205 @@
+# eval-review — repo-local skill/eval quality graders
+
+Static graders (free, no model) that check the **quality of skills and their
+evals** before they merge, plus an **opt-in LLM grader** for the judgment
+dimensions. They encode a skill/eval review: de-leading, assertion hardening,
+provenance hygiene, negative-scenario coverage (all static/free), and — behind an
+explicit `--llm` flag — fixture honesty, design balance, and domain-correctness.
+
+> **Enforcement is standalone, not via Vally.** These checks run in CI through the
+> `review.mjs` runner in this package — **not** through Vally. We verified that
+> `vally lint --grader-plugin` does **not** execute custom static graders against
+> skills (its lint registry only holds the three built-ins; the plugin registry is
+> used only to *validate* grader `type`s referenced in an eval spec), and that
+> `vally experiment run` — this repo's actual eval path — has no `--grader-plugin`
+> option at all. The graders are *also* exported as Vally `Grader` objects via
+> `registerGraders(registry)` so they can be loaded by `vally eval`/`grade` and
+> tested with Vally's APIs if the repo ever adopts those paths, but that is a
+> future/compatibility layer, not the current gate. See "Vally compatibility" below.
+
+## What it checks
+
+| Grader | Determinism | Checklist | What it flags |
+|---|---|---|---|
+| `eval-deleading` | static | A | Fixture comments / eval prompts that leak the answer (e.g. *"the right fix is …"*, a fixture that names the exact edit). High-confidence leaks only; generic smells stay MINOR. |
+| `assertion-hardening` | complex-static | B | A **mutating** scenario (edit/fix/migrate provided files) whose assertions are prose/`output_*`-only, with no result gate (`run_command_and_assert` / `file_contains` / `exit_success`). A wrong edit can still pass. |
+| `meta-commentary` | static | D5 | Unsupported provenance/empirical asides in shipped skill text (*"learned from telemetry"*, *"grounded in N PRs"*). Never *requires* provenance. |
+| `negative-scenario` | static | D4 | A real `DO NOT USE FOR` exclusion with **no** eval scenario asserting non-activation (`expect_activation: false`). |
+| `eval-review` | llm | C / D / DC | **Opt-in, paid.** A real judge-model call assessing fixture honesty (C), skill-design balance (D1–D3), and domain-correctness & safety (DC). Emits the same `[SEVERITY]/PROOF/WHY/FIX` findings. Off by default and **not** in the free CI gate; run with `review.mjs --llm`. |
+
+Findings use the review report shape:
+
+```
+[SEVERITY] dimension (rule) — file:line
+  PROOF: "<exact quoted text>"
+  WHY:   <why this matters>
+  FIX:   <concrete fix>
+```
+
+Severities: **BLOCKER > MAJOR > MINOR > INFO**. Verdict axis: **Rework**
+(any BLOCKER) / **Fix-then-ship** (any MAJOR/MINOR) / **Ship**.
+
+### Severity philosophy
+
+MAJOR is reserved for high-confidence, evidence-backed defects so reviewers never
+learn to ignore it:
+
+- **Evidence rule.** A MAJOR/BLOCKER with no quoted `file:line` proof is
+  automatically downgraded to MINOR (`lib/report.mjs`). No proof → no failing
+  severity.
+- **Intent-first classification.** `assertion-hardening` classifies each scenario
+  *before* demanding a result gate. It reads the scenario **name** first (the
+  author's one-line intent) and only treats **base-form imperative** verbs as
+  agent instructions — so *"the project generates a file"* (a description) is not
+  read as *"generate a file"* (an instruction). Only **editing existing provided
+  files** (fix/migrate/convert/refactor) earns MAJOR; *producing new* content
+  checked by keywords is under-asserted → MINOR. Advisory/diagnostic scenarios
+  (diagnose/explain/recommend, or "do not modify") are never flagged.
+- **Routing-risk tiering.** `negative-scenario` is MAJOR only when the exclusion
+  hands off to a **sibling skill** (`use some-other-skill`) — an untested routing
+  boundary that can misroute. A generic exclusion with no negative scenario is a
+  coverage gap → MINOR.
+
+## Usage
+
+```bash
+# One-time: install the runtime deps (js-yaml, argparse). The free static gate
+# only needs these; add the optional @github/copilot-sdk + zod (drop --omit) for --llm.
+cd eng/vally-graders && npm ci --omit=optional
+
+# From the repo root — evaluate only the skills touched by the PR (default):
+node eng/vally-graders/review.mjs
+
+# Evaluate everything:
+node eng/vally-graders/review.mjs --all
+
+# Focus on one skill; emit JSON:
+node eng/vally-graders/review.mjs --unit dotnet-test-migration/migrate-mstest-v3-to-v4 --json
+
+# Report-only a noisy dimension (prints, never blocks):
+node eng/vally-graders/review.mjs --report-only eval-deleading --report-only negative-scenario
+
+# Opt into the paid LLM grader (needs a Copilot token + optional deps installed):
+node eng/vally-graders/review.mjs --llm --unit dotnet-test-migration/migrate-mstest-v3-to-v4
+```
+
+Key flags: `--all`, `--base <ref>` (default `GITHUB_BASE_REF` or `main`),
+`--unit <substr>` (repeatable), `--report-only <dimension>` (repeatable),
+`--fail-on BLOCKER|MAJOR|MINOR` (default `MAJOR`), `--repo-root <path>`, `--json`,
+`--llm` (opt into the LLM grader), `--model <id>` (judge model for `--llm`).
+Exit code is non-zero when a blocking finding is present. Under GitHub Actions it
+also emits `::error`/`::warning` annotations.
+
+### LLM review (opt-in, paid — `--llm`)
+
+The `eval-review` grader makes a **real judge-model call** to assess the judgment
+dimensions the static graders can't: fixture honesty (C), skill-design balance
+(D1–D3), and domain-correctness & safety (DC). It is **off by default** and
+deliberately **excluded from the free CI gate** because it costs money/latency.
+
+- **Enable:** `review.mjs --llm`. Select the model with `--model <id>` or the
+  `EVAL_REVIEW_MODEL` env var (default `claude-opus-4.6`, matching the repo's
+  judge-model default in `eng/vally-adapter/adapt.mjs`).
+- **Auth + deps:** provisions the same client Vally's CLI uses via the optional
+  `@github/copilot-sdk` (+ `zod`) dependency; install with `npm ci` (i.e. **without**
+  `--omit=optional`). Needs a Copilot-scoped token in `GITHUB_COPILOT_API_TOKEN`,
+  `GITHUB_TOKEN`, or `GH_TOKEN`.
+- **Evidence discipline / anti-fabrication:** every model finding is routed through
+  the same evidence rule as the static graders — a MAJOR/BLOCKER with no quoted
+  `file:line` proof is downgraded, cited files must exist in the unit, and quoted
+  proof is verified against the unit's actual text (unverifiable quotes are
+  dropped). The grader **never** emits a BLOCKER on error.
+- **Graceful failure:** any SDK/token/model/timeout failure yields an
+  **inconclusive** NOTE (not a finding) and is excluded from the verdict, so a
+  missing token or offline run can never produce a false BLOCKER.
+- **Vally-compat:** still registered as a `determinism: "llm"` grader
+  (`experimental: true`) so `vally eval`/`grade --grader-plugin` can load it.
+
+### Suppression
+
+Add an inline `eval-review-ignore: <rule> — <rationale>` comment on or next to a
+flagged line to suppress a specific de-leading finding when a fixture *must*
+contain the smell (e.g. a fixture that deliberately models bad code).
+
+## CI wiring
+
+The gate runs in `.github/workflows/skill-check.yml` as **steps in the existing
+`check` job** (`on: pull_request`) — no separate workflow file — as a free,
+no-model check:
+
+1. `npm ci --omit=optional` + `npm test` — validates the graders themselves
+   (the paid LLM optional deps are skipped; the suite runs without them).
+2. `node eng/vally-graders/review.mjs --base origin/<base> --report-only
+   eval-deleading --report-only negative-scenario` — enforces the crisp
+   `assertion-hardening` / `meta-commentary` MAJORs while the noisier dimensions
+   surface as warnings during rollout. The paid `--llm` grader is **not** run here.
+
+**Scope.** The PR gate runs **changed units only** (the `--base origin/<base>`
+default). A **run-all** path is available for manual/nightly use via
+`review.mjs --all`, exposed in CI through the `EVAL_REVIEW_ALL=1` env toggle.
+
+**Dimension ratchet.** Tighten enforcement over time by removing `--report-only`
+flags as each dimension's backlog is burned down.
+
+> **Note — not added to the eval infra-glob.** `eng/vally-graders/` is intentionally
+> *not* in the `is_infra` change globs in `evaluation.yml`. Those globs trigger a
+> full model-eval smoke run, but the graders are not part of Vally's eval path, so a
+> grader change would burn eval budget for zero signal. Grader changes are instead
+> covered by `npm test` in the `check` job.
+
+## Vally compatibility (future layer, not the gate)
+
+`index.mjs` exports `registerGraders(registry)` (the `GraderPluginEntry`
+contract), so `eng/vally-graders` is loadable as a local grader plugin:
+
+```bash
+vally eval  --grader-plugin ./eng/vally-graders ...
+vally grade --grader-plugin ./eng/vally-graders ...
+```
+
+Custom graders execute in `eval`/`grade` (per trajectory), **not** in `lint`
+against skills, and **not** in `experiment`. To reference a grader `type` from an
+`eval.vally.yaml`, run via `eval`/`grade` with `--grader-plugin`.
+
+### Version pin (important)
+
+`--grader-plugin` availability was confirmed on the installed
+`@microsoft/vally-cli@0.6.0` (present on `lint`/`eval`/`grade`/`compare`/`export`,
+**absent on `experiment`**). The repo's Vally workflow installs the CLI **unpinned**
+(`latest`). If the repo ever routes these graders through Vally, pin
+`@microsoft/vally-cli` to a version known to support the intended flags and add a
+smoke test that fails loudly if `experiment` still can't load plugins.
+
+## Layout
+
+```
+index.mjs            # registerGraders(registry) + exports (staticModules, graders)
+review.mjs           # standalone CLI gate (the real enforcement path)
+graders/
+  eval-deleading.mjs        # A
+  assertion-hardening.mjs   # B
+  meta-commentary.mjs       # D5
+  negative-scenario.mjs     # D4
+  eval-review.mjs           # llm — opt-in judge-model grader (C/D/DC)
+lib/
+  locate.mjs         # skill<->eval discovery + eval.yaml/SKILL.md parsing
+  report.mjs         # finding model, [SEVERITY]/PROOF/WHY/FIX formatting, verdict
+  grader-base.mjs    # wraps a { metadata, review } module as a Vally Grader
+  llm-client.mjs     # @github/copilot-sdk provisioner for the --llm path
+tests/
+  graders.test.mjs   # node:test suite (run with `npm test`)
+  fixtures/repo/      # synthetic leaky + clean skill/eval pair
+```
+
+## Design notes
+
+- **Plain Node ESM `.mjs`**, matching the `eng/` convention (no TypeScript build).
+- **`js-yaml` dependency** is a deliberate deviation from `eng/`'s dependency-free
+  style — Node has no built-in YAML parser and eval specs are YAML. It (plus its
+  transitive `argparse`) is the only *required* runtime dependency; `npm ci
+  --omit=optional` installs it in CI. The `--llm` path additionally uses the
+  **optional** `@github/copilot-sdk` + `zod` deps (installed by a plain `npm ci`),
+  which the free static gate skips.
+- Dimensions **3 (full fixture right-vs-wrong discrimination)** and **5 (empirical
+  A/B value)** are out of scope for v1 static graders and are *not* claimed as
+  covered.
diff --git a/eng/vally-graders/graders/assertion-hardening.mjs b/eng/vally-graders/graders/assertion-hardening.mjs
new file mode 100644
index 0000000000..3e59cebc12
--- /dev/null
+++ b/eng/vally-graders/graders/assertion-hardening.mjs
@@ -0,0 +1,187 @@
+// assertion-hardening.mjs — CHECKLIST B: does the eval verify the RESULT?
+//
+// Classifies each scenario's intent BEFORE demanding a hard gate (per the
+// cross-family review — don't punish advisory/diagnostic evals):
+//   - mutating  (edits source: implement/fix/add/tag/refactor/...) -> a hard
+//     result gate is REQUIRED; prose/output_* only -> MAJOR (B1/B4).
+//   - advisory  (diagnose/explain/review/audit, or "without modifying") -> no
+//     gate demanded; we don't flag.
+//   - uncertain (neither clear) -> MINOR if no gate (report, don't block hard).
+//
+// A "hard gate" is run_command_and_assert / file_contains / file_not_contains /
+// file_exists / exit_success. output_contains / output_matches / rubric are NOT
+// hard gates on their own.
+
+import { finding, SEVERITY } from "../lib/report.mjs";
+import { isHardGate } from "../lib/locate.mjs";
+
+export const metadata = {
+  name: "assertion-hardening",
+  description: "Requires mutating eval scenarios to assert the RESULT (build/test/file gate), not just prose or output matches.",
+  behavior: { execution: "single" },
+  determinism: "complex-static",
+  portability: "t1-universal",
+  reference: "reference-free",
+  temporalScope: "point-in-time",
+  costProfile: "free",
+};
+
+const DIMENSION = "assertion-hardening";
+
+// Verbs that imply the agent must EDIT/PRODUCE code, matched only in IMPERATIVE
+// position (base form, at a clause boundary or after please/then/now). English
+// imperatives use the base form ("generate a class"); descriptive clauses use
+// 3rd-person ("the project generates a file") — matching base form only avoids
+// misreading a description of the codebase as an instruction to the agent.
+const MUT_VERBS =
+  "implement|fix|add|create|write|modify|update|refactor|rename|migrate|convert|replace|remove|delete|tag|generate|edit|apply|insert|scaffold|annotate|port|resolve|wire up|fill in|make";
+// Verbs that specifically EDIT EXISTING provided files (as opposed to producing
+// a new artifact shown in the answer). Only these, when the scenario supplies
+// files on disk, earn a MAJOR: a wrong edit to real project files can pass a
+// keyword-only assertion. "generate/write/create" produce new content and are
+// treated as the lower-severity under-assertion case.
+const EDIT_EXISTING =
+  /\b(fix|modify|update|refactor|rename|migrate|convert|replace|remove|delete|edit|port|annotate|tag|resolve|upgrade|downgrade|apply)\b/i;
+// Request wrappers that precede an agent-directed instruction ("help me fix",
+// "can you migrate", "I need you to update"). These let us catch mutating asks
+// that aren't at a raw clause boundary while still ignoring 3rd-person
+// descriptions of the codebase ("the project generates a file").
+const REQUEST =
+  "please|can you|could you|would you|help me|i need you to|i want you to|i'?d like you to|i need to|we need to|need to|let'?s|make sure to|ensure";
+const IMPERATIVE_MUTATING = new RegExp(
+  `(?:^|[.!?\\n]\\s*|["\`]|(?:${REQUEST})\\s+|then\\s+|now\\s+|and\\s+|,\\s+|-\\s+|how do i\\s+|how to\\s+)(?:${MUT_VERBS})\\b`,
+  "i",
+);
+
+// Verbs whose deliverable is analysis/advice (advisory), not a code change.
+const ADVISORY =
+  /\b(diagnose|diagnos(e|is|ing)|explain|describe|review|analy(z|s)e|analysis|recommend|compare|report|audit|summar(y|ize|ise)|identify|investigate|symbolicate|assess|evaluate|which|why does|why is|how does|tell me|should i|what should)\b/i;
+
+// Explicit "do not modify" signals force advisory classification.
+const NO_MODIFY =
+  /\b(without modifying|don'?t modify|do not modify|analysis only|report[- ]only|just give me|do not (edit|change)|without (editing|changing))\b/i;
+
+function classify(prompt) {
+  if (!prompt) return "uncertain";
+  if (NO_MODIFY.test(prompt)) return "advisory";
+  const mutating = IMPERATIVE_MUTATING.test(prompt);
+  const advisory = ADVISORY.test(prompt);
+  if (mutating && !advisory) return "mutating";
+  // A prompt that both instructs a change AND asks for explanation is a
+  // "diagnose-and-fix / show-me-and-explain" task. Whether it needs a hard gate
+  // depends on whether it edits provided files (decided in review()).
+  if (mutating && advisory) return "mixed";
+  if (advisory) return "advisory";
+  return "uncertain";
+}
+
+// The scenario NAME is the author's own one-line intent summary and is a
+// stronger signal than the prose prompt (which may quote a user asking for the
+// "wrong" thing that the skill should push back on). Prefer an unambiguous name
+// signal; otherwise fall back to the prompt.
+function classifyScenario(sc) {
+  const name = sc?.name ?? "";
+  if (name) {
+    const nameMutating = IMPERATIVE_MUTATING.test(name);
+    const nameAdvisory = ADVISORY.test(name);
+    if (nameMutating && !nameAdvisory) return "mutating";
+    if (nameAdvisory && !nameMutating) return "advisory";
+  }
+  return classify(sc?.prompt ?? "");
+}
+
+function scenarioLine(evalText, name) {
+  if (!evalText || !name) return null;
+  const lines = evalText.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(name)) return i + 1;
+  }
+  return null;
+}
+
+function review(unit) {
+  const findings = [];
+
+  // Prefer the native eval.yaml (authored source of truth); fall back to any.
+  const evalFile =
+    unit.evalFiles.find((e) => e.parsed.format === "native") ?? unit.evalFiles[0];
+  if (!evalFile) return findings;
+  const { parsed } = evalFile;
+  const evalText = parsed.text ?? "";
+
+  for (const sc of parsed.scenarios) {
+    // Non-activation scenarios: the agent should NOT act, so a result gate is
+    // not applicable here (negative-scenario grader owns that dimension).
+    if (sc.hasExpectActivationFalse) continue;
+
+    const hardGates = sc.assertionTypes.filter((t) => isHardGate(t));
+    const intent = classifyScenario(sc);
+    const line = scenarioLine(evalText, sc.name);
+    const proof = line ? textAt(evalText, line) : `scenario "${sc.name}"`;
+    const typesLabel = sc.assertionTypes.length ? sc.assertionTypes.join(", ") : "none";
+
+    if (hardGates.length > 0) continue; // has a real result gate — good.
+
+    // Does the scenario hand the agent existing project files to edit on disk?
+    // If so, an output-only assertion is a genuine, high-severity gap: a wrong
+    // edit to the provided files still passes. If instead the agent is asked to
+    // *produce* code shown in its answer (no setup files), output matching is
+    // under-asserted but lower risk -> MINOR, not MAJOR (don't cry wolf).
+    const editsProvidedFiles =
+      (Array.isArray(sc.setupFiles) && sc.setupFiles.length > 0) || sc.copyTestFiles === true;
+    // Is the agent editing existing provided files (highest risk) vs. producing
+    // new content? Only edit-existing on provided files earns a MAJOR.
+    const editsExisting =
+      EDIT_EXISTING.test(sc.name ?? "") || EDIT_EXISTING.test(sc.prompt ?? "");
+
+    if ((intent === "mutating" || intent === "mixed") && editsProvidedFiles && editsExisting) {
+      findings.push(
+        finding({
+          severity: SEVERITY.MAJOR,
+          dimension: DIMENSION,
+          rule: "B1",
+          file: evalFile.path,
+          line,
+          proof,
+          why: `Scenario sets up project files and asks the agent to change them, but only has weak assertions (${typesLabel}) and/or a prose rubric. A wrong or half-done edit to the provided files can still pass — the eval doesn't verify the RESULT.`,
+          fix: "Add a hard gate: run_command_and_assert (dotnet build / dotnet test) and/or file_contains / file_not_contains asserting the edited file's shape.",
+        }),
+      );
+    } else if (intent === "mutating" || intent === "mixed") {
+      findings.push(
+        finding({
+          severity: SEVERITY.MINOR,
+          dimension: DIMENSION,
+          rule: "B4",
+          file: evalFile.path,
+          line,
+          proof,
+          why: `Scenario asks the agent to produce code but only asserts on output text (${typesLabel}). Keyword matches can pass on code that does not compile or is subtly wrong (checklist B4: assert the RESULT, not the presence of keywords).`,
+          fix: "Have the eval write the produced code to a file and gate it: run_command_and_assert (dotnet build) or file_contains on the compiled/expected shape, instead of relying on output_contains alone.",
+        }),
+      );
+    } else if (intent === "uncertain") {
+      findings.push(
+        finding({
+          severity: SEVERITY.MINOR,
+          dimension: DIMENSION,
+          rule: "B1",
+          file: evalFile.path,
+          line,
+          proof,
+          why: `Scenario intent is ambiguous and it has no hard result gate (assertions: ${typesLabel}). If it expects a code change, it can be passed without producing a correct one.`,
+          fix: "If the scenario mutates code, add run_command_and_assert / file_contains. If it is advisory, tighten output_matches to a specific domain fact so it isn't trivially satisfiable.",
+        }),
+      );
+    }
+    // advisory + no gate -> intentionally no finding.
+    }
+
+    return findings;
+}
+
+function textAt(text, line) {
+  return (text.split("\n")[line - 1] ?? "").trim();
+}
+
+export { review, classify, classifyScenario };
diff --git a/eng/vally-graders/graders/eval-deleading.mjs b/eng/vally-graders/graders/eval-deleading.mjs
new file mode 100644
index 0000000000..524b328c70
--- /dev/null
+++ b/eng/vally-graders/graders/eval-deleading.mjs
@@ -0,0 +1,181 @@
+// eval-deleading.mjs — CHECKLIST A: does the eval leak the answer?
+//
+// Conservative + tiered on purpose (avoid crying wolf):
+//   - High-confidence leaks (a comment/prompt that pre-states the fix, the trap,
+//     or a status the model should deduce) -> MAJOR.
+//   - Generic "smell" comments -> MINOR/INFO for human triage.
+// An allowlist (A7) keeps legitimate domain metadata (<auto-generated/>,
+// back-compat notes, API-stability asides) from being flagged.
+//
+// Suppression: put `eval-review-ignore: A? — <rationale>` on the offending
+// line or the line directly above it.
+
+import { finding, SEVERITY } from "../lib/report.mjs";
+import { readRepoFile } from "../lib/locate.mjs";
+
+export const metadata = {
+  name: "eval-deleading",
+  description: "Flags eval fixtures/prompts that leak the answer (pre-labeled fixes, announced traps).",
+  behavior: { execution: "single" },
+  determinism: "static",
+  portability: "t1-universal",
+  reference: "reference-free",
+  temporalScope: "point-in-time",
+  costProfile: "free",
+};
+
+const DIMENSION = "eval-deleading";
+
+// High-confidence leak patterns (MAJOR). Applied to comment lines in fixtures
+// and to eval prompts.
+const HIGH_CONFIDENCE = [
+  { rule: "A2", re: /\bthe\s+(right|correct|proper|intended)\s+fix\s+(is\b|was\b|edits?\b|involves?\b|means?\b|requires?\b|would be\b|here\b|:)/i, why: "The fixture/prompt states the fix the eval is supposed to test the model for discovering." },
+  { rule: "A2", re: /\bmust be reflected in (every|all|each)\b/i, why: "Comment spells out the trap (the change must propagate), removing the thing the eval measures." },
+  { rule: "A2", re: /breaking change.{0,40}(won'?t|will not|can'?t|cannot)\s+(be\s+)?(caught|catch)/i, why: "Comment names the exact trap a green run would miss." },
+  { rule: "A3", re: /\bA SHIPPED\b/, why: "Doc-summary asserts a status (shipped/public API) the model is meant to deduce." },
+  { rule: "A1", re: /\b(should|must|need(s)? to)\s+(remove|delete|inline|rename|extract|consolidate|merge|deduplicate)\b/i, why: "Comment pre-labels the refactoring the eval wants the model to choose." },
+];
+
+// Prompt-only high-confidence: pre-announcing the hidden surface (A4).
+const PROMPT_HIGH_CONFIDENCE = [
+  { rule: "A4", re: /\bis a partial class\b/i, why: "Prompt pre-announces the hidden surface (partial class) the skill is meant to discover." },
+  { rule: "A4", re: /(must|should|needs? to)\s+(work|compile|build|run).{0,40}(every|all|each)\s+(target ?)?framework/i, why: "Prompt pre-announces the multi-TFM surface the skill is meant to discover." },
+];
+
+// Generic smells (MINOR) — comment lines in fixtures only.
+const SMELLS = [
+  { rule: "A1", re: /\b(duplicated block|duplicate block|near-identical|candidate to inline|rename target|poor name|copy[- ]paste|dead code)\b/i, why: "Comment reads like a pre-labeled refactoring cue rather than realistic code." },
+];
+
+// A7 allowlist: lines that look benign or are legitimate domain metadata.
+const ALLOWLIST = [
+  /<auto-generated/i,
+  /back-?compat/i,
+  /backward|backwards/i,
+  /\bobsolete\b/i,
+  /\bdeprecated\b/i,
+  /copyright|licensed under/i,
+];
+
+function isAllowlisted(line) {
+  return ALLOWLIST.some((re) => re.test(line));
+}
+
+function isCommentLine(line) {
+  const t = line.trim();
+  return (
+    t.startsWith("//") ||
+    t.startsWith("///") ||
+    t.startsWith("#") ||
+    t.startsWith("*") ||
+    t.startsWith("<!--") ||
+    t.startsWith("/*")
+  );
+}
+
+function suppressed(lines, idx) {
+  const here = lines[idx] ?? "";
+  const above = idx > 0 ? lines[idx - 1] ?? "" : "";
+  return /eval-review-ignore/i.test(here) || /eval-review-ignore/i.test(above);
+}
+
+function scanTextLines({ text, file, findings, patterns, commentOnly, severity }) {
+  if (!text) return;
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (commentOnly && !isCommentLine(line)) continue;
+    if (isAllowlisted(line)) continue;
+    if (suppressed(lines, i)) continue;
+    for (const p of patterns) {
+      if (p.re.test(line)) {
+        findings.push(
+          finding({
+            severity,
+            dimension: DIMENSION,
+            rule: p.rule,
+            file,
+            line: i + 1,
+            proof: line.trim(),
+            why: p.why,
+            fix: "Remove the leaking comment/phrasing; keep the opportunity discoverable from the code itself (A6). If intentional and benign, add `eval-review-ignore: <rule> — <rationale>`.",
+          }),
+        );
+        break; // one finding per line
+      }
+    }
+  }
+}
+
+function review(unit) {
+  const findings = [];
+  const repoRoot = unit.repoRoot ?? process.cwd();
+
+  // 1. Fixtures on disk: scan comment lines.
+  for (const rel of unit.fixtures) {
+    // Skip obvious binaries.
+    if (/\.(png|jpg|jpeg|gif|zip|dll|exe|pdb|snk|ico|nupkg)$/i.test(rel)) continue;
+    const text = readRepoFile(repoRoot, rel);
+    if (text == null) continue;
+    scanTextLines({ text, file: rel, findings, patterns: HIGH_CONFIDENCE, commentOnly: true, severity: SEVERITY.MAJOR });
+    scanTextLines({ text, file: rel, findings, patterns: SMELLS, commentOnly: true, severity: SEVERITY.MINOR });
+  }
+
+  // 2. Eval prompts + inline setup file contents.
+  for (const ef of unit.evalFiles) {
+    const evalText = ef.parsed.text ?? "";
+    for (const sc of ef.parsed.scenarios) {
+      // Prompt: high-confidence phrasing (both generic and prompt-specific).
+      scanPrompt({ prompt: sc.prompt, evalText, file: ef.path, findings });
+      // Inline fixture content declared via setup.files[].content.
+      for (const sf of sc.setupFiles) {
+        if (!sf.hasContent) continue;
+        scanTextLines({ text: sf.content, file: `${ef.path} (inline: ${sf.path})`, findings, patterns: HIGH_CONFIDENCE, commentOnly: true, severity: SEVERITY.MAJOR });
+        scanTextLines({ text: sf.content, file: `${ef.path} (inline: ${sf.path})`, findings, patterns: SMELLS, commentOnly: true, severity: SEVERITY.MINOR });
+      }
+    }
+  }
+
+  return findings;
+}
+
+function scanPrompt({ prompt, evalText, file, findings }) {
+  if (!prompt) return;
+  const patterns = [...HIGH_CONFIDENCE, ...PROMPT_HIGH_CONFIDENCE];
+  for (const p of patterns) {
+    const m = p.re.exec(prompt);
+    if (m) {
+      // Locate the matched phrase in the raw eval file for a real file:line.
+      const matched = m[0];
+      const line = lineOfPhrase(evalText, matched);
+      findings.push(
+        finding({
+          severity: SEVERITY.MAJOR,
+          dimension: DIMENSION,
+          rule: p.rule,
+          file,
+          line,
+          proof: line ? textAtLine(evalText, line) : matched,
+          why: p.why,
+          fix: "Rewrite the prompt to capture intent/operation only (A5); do not name the mechanics, location, or hidden surface of the fix.",
+        }),
+      );
+    }
+  }
+}
+
+function lineOfPhrase(text, phrase) {
+  if (!text || !phrase) return null;
+  const lines = text.split("\n");
+  const needle = phrase.toLowerCase();
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].toLowerCase().includes(needle)) return i + 1;
+  }
+  return null;
+}
+
+function textAtLine(text, line) {
+  return (text.split("\n")[line - 1] ?? "").trim();
+}
+
+export { review };
diff --git a/eng/vally-graders/graders/eval-review.mjs b/eng/vally-graders/graders/eval-review.mjs
new file mode 100644
index 0000000000..58d2d4e2af
--- /dev/null
+++ b/eng/vally-graders/graders/eval-review.mjs
@@ -0,0 +1,394 @@
+// eval-review.mjs — the `eval-review` LLM grader.
+//
+// Covers the judgment dimensions that the free static graders cannot:
+//   C  — fixture honesty & integrity (is the trap real; does it discriminate a
+//        right vs. wrong fix; do assertions/fixtures line up)
+//   D  — skill-design balance (D1–D3): guidance names tradeoffs and *when* to
+//        take each side, not just a list of prohibitions
+//   DC — domain-correctness & safety: claims are defensible; no harmful guidance
+//
+// It makes a REAL judge-model call via the Copilot SDK (see lib/llm-client.mjs)
+// and emits real [SEVERITY]/PROOF/WHY/FIX findings. It is opt-in (review.mjs
+// --llm) and kept OUT of the free per-PR gate because it costs money/latency.
+//
+// Discipline (never a false BLOCKER):
+//   * Every model finding is routed through report.finding(), which downgrades
+//     any MAJOR/BLOCKER lacking a quoted proof to MINOR.
+//   * Cited file paths are verified against the unit's real files; unknown files
+//     are dropped (file/line nulled).
+//   * Quoted proof is verified against the unit's source text; unverifiable
+//     quotes are dropped (→ the finding downgrades).
+//   * Any SDK/token/timeout/parse failure returns an INCONCLUSIVE result
+//     (excluded from the verdict), not a finding.
+
+import { finding, SEVERITY, verdict, isBlocking, formatFinding } from "../lib/report.mjs";
+import { readRepoFile } from "../lib/locate.mjs";
+import { createCopilotLlmClient, LlmUnavailableError } from "../lib/llm-client.mjs";
+
+export const DEFAULT_MODEL = process.env.EVAL_REVIEW_MODEL || "claude-opus-4.6";
+
+export const metadata = {
+  name: "eval-review",
+  description:
+    "LLM review of fixture honesty (C), skill-design balance (D1–D3), and domain-correctness & safety (DC). Real judge-model call; opt-in, not in the free gate.",
+  behavior: { execution: "single", requiresLlmClient: true, requiresWorkspace: true },
+  determinism: "llm",
+  portability: "t1-universal",
+  reference: "reference-free",
+  temporalScope: "point-in-time",
+  costProfile: "low",
+  experimental: true,
+};
+
+const DIMENSION_RULE = {
+  "C-fixture-integrity": "C",
+  "D-design-balance": "D",
+  "DC-domain-correctness": "DC",
+};
+
+// ---------------------------------------------------------------------------
+// Prompt construction (pure — unit-testable without a model)
+// ---------------------------------------------------------------------------
+
+function truncate(s, n) {
+  if (typeof s !== "string") return "";
+  return s.length > n ? `${s.slice(0, n)}\n…[truncated ${s.length - n} chars]` : s;
+}
+
+export const SYSTEM_MESSAGE = [
+  "You are an exacting reviewer of AI-agent *skills* and their *evals* for the dotnet/skills repository.",
+  "Assess ONLY these dimensions and nothing else:",
+  "  C  (fixture-integrity): Is the eval's trap real? Do fixtures + assertions actually discriminate a CORRECT fix from a plausible WRONG one, or could a trivial/incorrect change also pass? Are setup files, prompts, and assertions mutually consistent?",
+  "  D  (design-balance): Does the SKILL.md guidance name real tradeoffs and say WHEN to choose each side, rather than being a bare list of 'do NOT' prohibitions? Flag guidance that is one-sided or absolutist without conditions.",
+  "  DC (domain-correctness & safety): Are technical claims defensible for .NET/C#/tooling? Any incorrect, misleading, or unsafe guidance?",
+  "",
+  "You are given only the SKILL.md text and eval scenarios provided in the user message. Judge ONLY that material.",
+  "",
+  "EVIDENCE DISCIPLINE (strict):",
+  "  * Every MAJOR or BLOCKER finding MUST include a `proof`: a short verbatim quote copied EXACTLY from the provided material, plus the `file` it came from (use the exact file paths given).",
+  "  * If you cannot quote exact supporting text, use severity MINOR or INFO — do NOT assert MAJOR/BLOCKER.",
+  "  * NEVER invent file paths, line numbers, or quotes. Do not paraphrase inside `proof`.",
+  "  * If the material is insufficient to judge a dimension, record a single INFO finding saying so.",
+  "",
+  "Severities: BLOCKER (ships incorrect or unsafe guidance), MAJOR (clear, proven defect), MINOR (smell or unproven concern), INFO (note/insufficient-evidence).",
+  "Report by calling the submit_review tool exactly once. If there are no real issues, submit an empty findings array with verdict 'Ship'.",
+].join("\n");
+
+/** Build the {systemMessage, userMessage} for a unit. Pure. */
+export function buildPrompt(unit) {
+  const parts = [];
+  parts.push(`# Unit: ${unit.plugin ?? "?"}/${unit.name ?? "?"} (kind: ${unit.kind ?? "skill"})`);
+  parts.push("");
+  parts.push(`## Skill document: ${unit.skillDoc ?? "(none resolved)"}`);
+  parts.push(unit.skillDocText ? truncate(unit.skillDocText, 9000) : "(no skill document text available)");
+  parts.push("");
+
+  const evalFiles = Array.isArray(unit.evalFiles) ? unit.evalFiles : [];
+  if (evalFiles.length === 0) {
+    parts.push("## Evals: (none found for this unit)");
+  }
+  for (const ef of evalFiles) {
+    parts.push(`## Eval file: ${ef.path} (format: ${ef.parsed?.format ?? "unknown"})`);
+    const scenarios = Array.isArray(ef.parsed?.scenarios) ? ef.parsed.scenarios : [];
+    if (scenarios.length === 0) parts.push("(no scenarios parsed)");
+    scenarios.forEach((s, i) => {
+      parts.push(`### Scenario ${i + 1}: ${s.name || "(unnamed)"}`);
+      parts.push(`- prompt: ${truncate(s.prompt, 700)}`);
+      parts.push(`- assertion types: ${(s.assertionTypes ?? []).join(", ") || "(none)"}`);
+      if (Array.isArray(s.rubric) && s.rubric.length) {
+        parts.push(`- rubric: ${s.rubric.map((r) => truncate(String(r), 200)).join(" | ")}`);
+      }
+      const setupFiles = Array.isArray(s.setupFiles) ? s.setupFiles : [];
+      if (setupFiles.length) {
+        parts.push(`- setup files: ${setupFiles.map((f) => f.path).join(", ")}`);
+      }
+      if (s.hasExpectActivationFalse) parts.push("- expect_activation: false");
+    });
+    parts.push("");
+  }
+
+  const fixtures = Array.isArray(unit.fixtures) ? unit.fixtures : [];
+  if (fixtures.length) {
+    parts.push(`## Fixtures (paths): ${fixtures.join(", ")}`);
+  }
+
+  return { systemMessage: SYSTEM_MESSAGE, userMessage: parts.join("\n") };
+}
+
+// ---------------------------------------------------------------------------
+// Tool schema (lazy zod import — optional dependency)
+// ---------------------------------------------------------------------------
+
+async function buildTool() {
+  let parameters;
+  try {
+    const { z } = await import("zod");
+    const Finding = z.object({
+      severity: z.enum(["BLOCKER", "MAJOR", "MINOR", "INFO"]),
+      dimension: z.enum(["C-fixture-integrity", "D-design-balance", "DC-domain-correctness"]),
+      file: z.string().optional(),
+      line: z.number().int().optional(),
+      proof: z.string().optional(),
+      why: z.string(),
+      fix: z.string(),
+    });
+    parameters = z.object({
+      findings: z.array(Finding),
+      verdict: z.enum(["Ship", "Fix-then-ship", "Rework"]),
+      summary: z.string(),
+    });
+  } catch {
+    // zod (optional dep) not installed — fall back to a minimal schema object
+    // that exposes the `.safeParse` the client relies on. This keeps the
+    // injected-client path (and its tests) working without the optional deps;
+    // the real SDK path installs zod so it gets a proper JSON schema.
+    parameters = {
+      safeParse(v) {
+        if (!v || typeof v !== "object") {
+          return { success: false, error: { message: "expected an object" } };
+        }
+        return {
+          success: true,
+          data: {
+            findings: Array.isArray(v.findings) ? v.findings : [],
+            verdict: typeof v.verdict === "string" ? v.verdict : "Fix-then-ship",
+            summary: typeof v.summary === "string" ? v.summary : "",
+          },
+        };
+      },
+    };
+  }
+  return {
+    name: "submit_review",
+    description:
+      "Submit the eval-review findings for this unit. Call exactly once. Every MAJOR/BLOCKER finding must include an exact `proof` quote and the `file` it came from.",
+    parameters,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Result mapping (pure — anti-fabrication + evidence discipline)
+// ---------------------------------------------------------------------------
+
+/** Whitespace-normalize for lenient proof verification. */
+function norm(s) {
+  return String(s ?? "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+/** Concatenated source text for a unit (skill doc + eval files + fixtures). */
+function unitCorpus(unit) {
+  const chunks = [];
+  if (unit.skillDocText) chunks.push(unit.skillDocText);
+  for (const ef of unit.evalFiles ?? []) {
+    if (ef.parsed?.text) chunks.push(ef.parsed.text);
+  }
+  if (unit.repoRoot && Array.isArray(unit.fixtures)) {
+    for (const rel of unit.fixtures) {
+      const t = readRepoFile(unit.repoRoot, rel);
+      if (t) chunks.push(t);
+    }
+  }
+  return norm(chunks.join("\n"));
+}
+
+function knownFileSet(unit) {
+  const files = new Set();
+  if (unit.skillDoc) files.add(unit.skillDoc);
+  for (const ef of unit.evalFiles ?? []) if (ef.path) files.add(ef.path);
+  for (const rel of unit.fixtures ?? []) files.add(rel);
+  return files;
+}
+
+/**
+ * Map raw model output to Finding[]. Verifies cited files + quoted proof against
+ * the unit; drops unverifiable citations so unproven MAJOR/BLOCKER downgrade.
+ */
+export function mapFindings(args, unit) {
+  const raw = Array.isArray(args?.findings) ? args.findings : [];
+  const known = knownFileSet(unit);
+  const corpus = unitCorpus(unit);
+  const out = [];
+  for (const r of raw) {
+    let file = typeof r.file === "string" ? r.file.replace(/^\.\//, "").trim() : null;
+    let line = Number.isInteger(r.line) ? r.line : null;
+    if (file && !known.has(file)) {
+      // Hallucinated / unknown file — don't trust the location.
+      file = null;
+      line = null;
+    }
+    let proof = typeof r.proof === "string" ? r.proof.trim() : "";
+    if (proof) {
+      const np = norm(proof);
+      // Accept if a >=12-char slice of the quote appears in the corpus (lenient
+      // to tolerate light truncation); short quotes must match whole.
+      const probe = np.length >= 12 ? np.slice(0, Math.min(np.length, 60)) : np;
+      const verified = corpus.length > 0 && probe.length > 0 && corpus.includes(probe);
+      if (!verified) proof = ""; // unverifiable → drop → severity downgrades
+    }
+    const why = typeof r.why === "string" ? r.why : "";
+    const augmentedWhy =
+      typeof r.proof === "string" && r.proof.trim() && !proof
+        ? `${why} [unverified quote omitted: ${truncate(r.proof.trim(), 160)}]`
+        : why;
+    out.push(
+      finding({
+        severity: r.severity ?? SEVERITY.MINOR,
+        dimension: "eval-review",
+        rule: DIMENSION_RULE[r.dimension] ?? r.dimension ?? null,
+        file,
+        line,
+        proof: proof || undefined,
+        why: augmentedWhy,
+        fix: typeof r.fix === "string" ? r.fix : "",
+      }),
+    );
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Core: run one unit through the model
+// ---------------------------------------------------------------------------
+
+/** Shape of an inconclusive (non-failing) result. */
+function inconclusive(reason) {
+  return { ran: false, inconclusive: true, reason, findings: [], verdict: "Ship", usage: null };
+}
+
+/**
+ * Review a single unit with the model.
+ * @param {object} unit
+ * @param {{ client?: object, model?: string, timeoutMs?: number }} [opts]
+ *   client: a pre-provisioned LlmClient (with judge()); if omitted, one is
+ *   created via the Copilot SDK and shut down afterwards.
+ */
+export async function reviewUnit(unit, opts = {}) {
+  const model = opts.model || DEFAULT_MODEL;
+
+  let tool;
+  try {
+    tool = await buildTool();
+  } catch (err) {
+    return inconclusive(`zod (optional dep) unavailable: ${err?.message ?? err}`);
+  }
+
+  const { systemMessage, userMessage } = buildPrompt(unit);
+
+  let client = opts.client;
+  let ownClient = false;
+  if (!client) {
+    try {
+      client = await createCopilotLlmClient();
+      ownClient = true;
+    } catch (err) {
+      if (err instanceof LlmUnavailableError) return inconclusive(err.message);
+      return inconclusive(`could not provision llm client: ${err?.message ?? err}`);
+    }
+  }
+
+  try {
+    const res = await client.judge({
+      model,
+      systemMessage,
+      userMessage,
+      tool,
+      timeoutMs: opts.timeoutMs ?? 120_000,
+    });
+    const findings = mapFindings(res.args, unit);
+    return {
+      ran: true,
+      inconclusive: false,
+      reason: null,
+      findings,
+      verdict: verdict(findings),
+      usage: res.tokenUsage ?? null,
+      model,
+    };
+  } catch (err) {
+    return inconclusive(`model call failed: ${err?.message ?? err}`);
+  } finally {
+    if (ownClient && client?.shutdown) await client.shutdown();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Vally Grader adapter
+// ---------------------------------------------------------------------------
+
+function toGraderResult(unitLabel, result) {
+  if (result.inconclusive) {
+    return {
+      name: metadata.name,
+      kind: "llm",
+      passed: true, // inconclusive is excluded from the verdict — never fails
+      score: 1,
+      label: "inconclusive",
+      evidence: `eval-review did not run a model judgment for ${unitLabel}: ${result.reason}`,
+      details: [],
+      metadata: { inconclusive: true, reason: result.reason, findings: [] },
+    };
+  }
+  const blocking = result.findings.filter((f) => isBlocking(f.severity));
+  const passed = blocking.length === 0;
+  return {
+    name: metadata.name,
+    kind: "llm",
+    passed,
+    score: passed ? 1 : 0,
+    label: result.verdict,
+    evidence:
+      result.findings.length === 0
+        ? `eval-review: no issues found for ${unitLabel}.`
+        : result.findings.map(formatFinding).join("\n"),
+    details: result.findings.map((f) => ({
+      name: `eval-review:${f.rule ?? "?"}`,
+      kind: "llm",
+      passed: !isBlocking(f.severity),
+      score: isBlocking(f.severity) ? 0 : 1,
+      label: f.severity,
+      evidence: formatFinding(f),
+    })),
+    metadata: { findings: result.findings, usage: result.usage, model: result.model },
+  };
+}
+
+/**
+ * Build a Vally-compatible grader object. `client` is optional: when Vally (or a
+ * test) supplies an LlmClient it is used; otherwise grade() provisions its own
+ * via the Copilot SDK, and reports inconclusive if that isn't possible.
+ *
+ * NOTE: Vally does not currently enforce this grader in dotnet/skills' eval path
+ * (see README/index.mjs). This adapter exists for Vally-compat / future use.
+ */
+export function createGrader({ client, model } = {}) {
+  return {
+    metadata,
+    async grade(input) {
+      const cwd = input?.config?.cwd ?? process.cwd();
+      const env = input?.stimulus?.environment;
+      const skillDirs = env?.skills ?? [];
+      const injected = client ?? input?.config?.llmClient;
+      const chosenModel = model ?? input?.config?.model ?? DEFAULT_MODEL;
+
+      // Resolve the unit from the provided skill dir(s).
+      const { unitsFromSkillDirs } = await import("../lib/locate.mjs");
+      const units = skillDirs.length ? unitsFromSkillDirs(cwd, skillDirs) : [];
+      if (units.length === 0) {
+        return toGraderResult("(no unit)", inconclusive("no skill provided in stimulus.environment.skills"));
+      }
+      // Single-execution grader: review the first resolved unit.
+      const unit = units[0];
+      const result = await reviewUnit(unit, { client: injected, model: chosenModel });
+      return toGraderResult(`${unit.plugin}/${unit.name}`, result);
+    },
+  };
+}
+
+export const grader = createGrader();
+
+export async function grade(input) {
+  return grader.grade(input);
+}
diff --git a/eng/vally-graders/graders/meta-commentary.mjs b/eng/vally-graders/graders/meta-commentary.mjs
new file mode 100644
index 0000000000..bafd4c9069
--- /dev/null
+++ b/eng/vally-graders/graders/meta-commentary.mjs
@@ -0,0 +1,118 @@
+// meta-commentary.mjs — CHECKLIST D5: no provenance / meta-commentary in shipped
+// SKILL.md or references.
+//
+// Inverted per the cross-family review: we flag *unsupported empirical claims*
+// and authoring provenance that leaked into shipped text ("learned from
+// telemetry", "grounded in N PRs", "in our experiments"). We NEVER require
+// provenance phrasing — the goal is to strip authoring asides, not reward them.
+
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { finding, SEVERITY } from "../lib/report.mjs";
+
+export const metadata = {
+  name: "meta-commentary",
+  description: "Flags authoring provenance / unsupported empirical claims left in shipped SKILL.md or references.",
+  behavior: { execution: "single" },
+  determinism: "static",
+  portability: "t1-universal",
+  reference: "reference-free",
+  temporalScope: "point-in-time",
+  costProfile: "free",
+};
+
+const DIMENSION = "meta-commentary";
+
+// Strong provenance leaks (MAJOR) — clearly authoring/telemetry asides.
+const STRONG = [
+  { rule: "D5", re: /learned from telemetry/i, why: "Shipped text reveals the skill was reverse-engineered from telemetry — authoring provenance that doesn't belong in guidance." },
+  { rule: "D5", re: /grounded in\s+\d+/i, why: "Empirical provenance claim ('grounded in N ...') leaked into shipped guidance." },
+  { rule: "D5", re: /based on .{0,25}\d+\s+(real\s+|merged\s+)*(prs?|pull requests?|commits?)/i, why: "Unsupported empirical provenance ('based on N PRs/commits') in shipped text." },
+  { rule: "D5", re: /derived from (analy(z|s)ing|analysis of)\s+\d+/i, why: "Authoring provenance ('derived from analyzing N ...') leaked into shipped guidance." },
+];
+
+// Softer author asides / scope claims (MINOR).
+const SOFT = [
+  { rule: "D5", re: /\bin (our|my) (experiments?|testing|telemetry|dataset)\b/i, why: "Author aside about experiments/telemetry in shipped guidance." },
+  { rule: "D5", re: /\bwe (found|observed|noticed|saw|discovered) that\b/i, why: "First-person authoring aside in shipped guidance." },
+  { rule: "D5", re: /\b(across|from)\s+\d+\s+(real\s+)?(merged\s+)?(prs?|pull requests?|repos|repositories)\b/i, why: "Empirical scope claim ('across N repos/PRs') presented without support." },
+];
+
+function readText(p) {
+  try {
+    return readFileSync(p, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// Collect the skill/agent doc plus reference markdown that ships with it.
+function docPaths(unit) {
+  const paths = [];
+  if (unit.skillDocAbs) paths.push(unit.skillDocAbs);
+  if (unit.kind === "skill" && unit.skillDir) {
+    const skillDirAbs = join(unit.repoRoot, ...unit.skillDir.split("/"));
+    for (const p of walkMarkdown(skillDirAbs)) {
+      if (p !== unit.skillDocAbs) paths.push(p);
+    }
+  }
+  return paths;
+}
+
+function walkMarkdown(dir, acc = []) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return acc;
+  }
+  for (const e of entries) {
+    const full = join(dir, e.name);
+    if (e.isDirectory()) walkMarkdown(full, acc);
+    else if (e.isFile() && /\.md$/i.test(e.name)) acc.push(full);
+  }
+  return acc;
+}
+
+function review(unit) {
+  const findings = [];
+  const repoRoot = unit.repoRoot ?? process.cwd();
+  for (const abs of docPaths(unit)) {
+    const text = readText(abs);
+    if (text == null) continue;
+    const rel = relative(repoRoot, abs).split(sep).join("/");
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (/eval-review-ignore/i.test(line)) continue;
+      for (const p of STRONG) {
+        if (p.re.test(line)) {
+          findings.push(mk(SEVERITY.MAJOR, p, rel, i + 1, line));
+          break;
+        }
+      }
+      for (const p of SOFT) {
+        if (p.re.test(line)) {
+          findings.push(mk(SEVERITY.MINOR, p, rel, i + 1, line));
+          break;
+        }
+      }
+    }
+  }
+  return findings;
+}
+
+function mk(severity, p, file, line, raw) {
+  return finding({
+    severity,
+    dimension: DIMENSION,
+    rule: p.rule,
+    file,
+    line,
+    proof: raw.trim(),
+    why: p.why,
+    fix: "Remove the authoring/provenance aside. Keep the guidance itself; state the rule, not how it was derived.",
+  });
+}
+
+export { review };
diff --git a/eng/vally-graders/graders/negative-scenario.mjs b/eng/vally-graders/graders/negative-scenario.mjs
new file mode 100644
index 0000000000..77d5c1bec0
--- /dev/null
+++ b/eng/vally-graders/graders/negative-scenario.mjs
@@ -0,0 +1,101 @@
+// negative-scenario.mjs — CHECKLIST D4: a real "DO NOT USE FOR" must be backed
+// by a non-activation eval scenario.
+//
+// If the skill/agent doc declares an exclusion ("DO NOT USE FOR ...") but NO
+// mapped eval scenario asserts non-activation (expect_activation: false), the
+// exclusion is untested -> MAJOR. Searches ALL eval files mapped to the unit.
+
+import { finding, SEVERITY } from "../lib/report.mjs";
+
+export const metadata = {
+  name: "negative-scenario",
+  description: "Requires a non-activation eval scenario when the skill declares a DO NOT USE FOR exclusion.",
+  behavior: { execution: "single" },
+  determinism: "static",
+  portability: "t1-universal",
+  reference: "reference-free",
+  temporalScope: "point-in-time",
+  costProfile: "free",
+};
+
+const DIMENSION = "negative-scenario";
+
+// Match a genuine exclusion clause. Require the "for" to avoid matching prose
+// like "do not use the deprecated API".
+const DO_NOT_USE_FOR = /\bDO NOT USE FOR\b/i;
+
+// An explicit handoff to a *sibling skill* (kebab-case name after "use ...").
+// When present, misrouting has real cost (the wrong tool/flow runs), so an
+// untested boundary is MAJOR. Otherwise a missing non-activation scenario is a
+// coverage gap -> MINOR. (v2: match the negative scenario to the exclusion's
+// subject instead of accepting any expect_activation:false anywhere.)
+const SIBLING_HANDOFF = /\buse\s+[`'"]?[a-z][a-z0-9]*(?:-[a-z0-9]+)+\b/i;
+
+function findExclusion(text) {
+  if (!text) return null;
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (DO_NOT_USE_FOR.test(lines[i])) {
+      // Include up to two following lines: exclusion clauses often wrap.
+      const context = [lines[i], lines[i + 1] ?? "", lines[i + 2] ?? ""].join(" ");
+      return { line: i + 1, text: lines[i].trim(), context };
+    }
+  }
+  return null;
+}
+
+function review(unit) {
+  const findings = [];
+  if (!unit.skillDocText) return findings; // nothing to assert against
+
+  const exclusion = findExclusion(unit.skillDocText);
+  if (!exclusion) return findings; // no exclusion declared -> N/A
+
+  // Any non-activation scenario anywhere in the mapped evals satisfies D4.
+  const hasNegative = unit.evalFiles.some((ef) =>
+    ef.parsed.scenarios.some((sc) => sc.hasExpectActivationFalse),
+  );
+
+  if (hasNegative) return findings;
+
+  // No eval files at all -> can't test; report INFO rather than a failing sev.
+  if (unit.evalFiles.length === 0) {
+    findings.push(
+      finding({
+        severity: SEVERITY.INFO,
+        dimension: DIMENSION,
+        rule: "D4",
+        file: unit.skillDoc,
+        line: exclusion.line,
+        proof: exclusion.text,
+        why: "Skill declares an exclusion but has no eval file, so non-activation can't be verified.",
+        fix: "Add an eval with a scenario using expect_activation: false that exercises the excluded case.",
+      }),
+    );
+    return findings;
+  }
+
+  // Routing risk drives severity: an explicit "use <sibling-skill>" handoff that
+  // is untested can misroute to the wrong tool -> MAJOR. A generic exclusion with
+  // no negative scenario is coverage debt -> MINOR (don't dilute MAJOR).
+  const routingRisk = SIBLING_HANDOFF.test(exclusion.context);
+  const evalList = unit.evalFiles.map((e) => e.path).join(", ");
+
+  findings.push(
+    finding({
+      severity: routingRisk ? SEVERITY.MAJOR : SEVERITY.MINOR,
+      dimension: DIMENSION,
+      rule: "D4",
+      file: unit.skillDoc,
+      line: exclusion.line,
+      proof: exclusion.text,
+      why: routingRisk
+        ? "The exclusion hands off to a sibling skill (\"use <other-skill>\") but no eval scenario asserts non-activation (expect_activation: false). The routing boundary is unenforced — nothing stops this skill from activating on a case that belongs to the other skill."
+        : "The skill declares a DO NOT USE FOR exclusion, but no eval scenario asserts non-activation (expect_activation: false). The boundary is untested (coverage gap).",
+      fix: `Add a scenario to one of this skill's evals (${evalList}) that uses expect_activation: false and prompts for the excluded use case.`,
+    }),
+  );
+  return findings;
+}
+
+export { review };
diff --git a/eng/vally-graders/index.mjs b/eng/vally-graders/index.mjs
new file mode 100644
index 0000000000..bf53a1dcfc
--- /dev/null
+++ b/eng/vally-graders/index.mjs
@@ -0,0 +1,55 @@
+// index.mjs — Vally grader-plugin entry point for dotnet/skills.
+//
+// Exports `registerGraders(registry)` (the GraderPluginEntry contract) so the
+// graders can be loaded by `vally eval|grade --grader-plugin ./eng/vally-graders`.
+//
+// IMPORTANT — enforcement path: these checks are enforced in CI by the
+// standalone runner (review.mjs), NOT by Vally. `vally lint --grader-plugin`
+// does not execute custom static graders against skills, and `vally experiment
+// run` (this repo's eval path) cannot load grader plugins. See README.md.
+
+import { makeStaticGrader } from "./lib/grader-base.mjs";
+
+import * as deleading from "./graders/eval-deleading.mjs";
+import * as assertionHardening from "./graders/assertion-hardening.mjs";
+import * as metaCommentary from "./graders/meta-commentary.mjs";
+import * as negativeScenario from "./graders/negative-scenario.mjs";
+import * as evalReview from "./graders/eval-review.mjs";
+
+// The free, no-model static graders. Each module exports { metadata, review }.
+const STATIC_MODULES = [deleading, assertionHardening, metaCommentary, negativeScenario];
+
+/** Static grader objects (Vally Grader shape) built from the modules. */
+export const staticGraders = STATIC_MODULES.map((m) =>
+  makeStaticGrader({ metadata: m.metadata, review: m.review }),
+);
+
+/** The llm grader (eval-review — real judge-model call; opt-in via review.mjs --llm). */
+export const llmGrader = evalReview.grader;
+
+/** All graders this plugin provides. */
+export const graders = [...staticGraders, llmGrader];
+
+/**
+ * GraderPluginEntry contract: register every grader with the Vally registry.
+ * @param {{ register: (grader: object) => void }} registry
+ */
+export function registerGraders(registry) {
+  for (const g of graders) registry.register(g);
+}
+
+// Re-export the raw modules so the standalone runner and tests can call the
+// core `review(unit)` directly without going through the Vally adapter.
+export const staticModules = STATIC_MODULES;
+
+// The llm grader module (eval-review), for the standalone --llm path and tests.
+export const llmModule = evalReview;
+
+export default {
+  registerGraders,
+  graders,
+  staticGraders,
+  llmGrader,
+  staticModules,
+  llmModule,
+};
diff --git a/eng/vally-graders/lib/grader-base.mjs b/eng/vally-graders/lib/grader-base.mjs
new file mode 100644
index 0000000000..4d61b6b883
--- /dev/null
+++ b/eng/vally-graders/lib/grader-base.mjs
@@ -0,0 +1,65 @@
+// grader-base.mjs — adapt a repo-local `review(unit) -> Finding[]` core into the
+// Vally Grader contract, so the exact same logic powers both the standalone
+// per-PR runner (review.mjs) and `vally eval --grader-plugin ./eng/vally-graders`.
+
+import { unitsFromSkillDirs } from "./locate.mjs";
+import { finding, formatFinding, isBlocking, verdict, SEVERITY } from "./report.mjs";
+
+export { finding, SEVERITY };
+
+/**
+ * @param {object} spec
+ * @param {object} spec.metadata  Vally GraderMetadata (name, determinism, ...)
+ * @param {(unit: object) => object[]} spec.review  core check: unit -> Finding[]
+ * @param {string} [spec.dimension]  default dimension id for findings
+ */
+export function makeStaticGrader(spec) {
+  const { metadata, review } = spec;
+  return {
+    metadata,
+    review, // exposed for the standalone runner + tests
+    async grade(input) {
+      const env = input?.stimulus?.environment;
+      const skillDirs = env?.skills ?? [];
+      const cwd = input?.config?.cwd ?? process.cwd();
+      if (!skillDirs.length) {
+        throw new Error(`${metadata.name} grader requires at least one skill in stimulus.environment.skills`);
+      }
+      const units = unitsFromSkillDirs(cwd, skillDirs);
+      const allFindings = [];
+      const details = [];
+      for (const unit of units) {
+        const findings = review(unit);
+        allFindings.push(...findings);
+        const blocking = findings.filter((f) => isBlocking(f.severity));
+        details.push({
+          name: `${metadata.name}:${unit.plugin}/${unit.name}`,
+          kind: "code",
+          passed: blocking.length === 0,
+          score: blocking.length === 0 ? 1 : 0,
+          label: verdict(findings),
+          evidence:
+            findings.length === 0
+              ? "no findings"
+              : findings.map(formatFinding).join("\n"),
+        });
+      }
+      const blocking = allFindings.filter((f) => isBlocking(f.severity));
+      const passed = blocking.length === 0;
+      return {
+        name: metadata.name,
+        kind: "code",
+        passed,
+        score: passed ? 1 : 0,
+        label: verdict(allFindings),
+        evidence: passed
+          ? `${metadata.name}: no blocking findings across ${units.length} unit(s).`
+          : `${metadata.name}: ${blocking.length} blocking finding(s).\n${blocking
+              .map(formatFinding)
+              .join("\n")}`,
+        details,
+        metadata: { findings: allFindings },
+      };
+    },
+  };
+}
diff --git a/eng/vally-graders/lib/llm-client.mjs b/eng/vally-graders/lib/llm-client.mjs
new file mode 100644
index 0000000000..ee5fbde449
--- /dev/null
+++ b/eng/vally-graders/lib/llm-client.mjs
@@ -0,0 +1,174 @@
+// llm-client.mjs — thin, lazy wrapper over @github/copilot-sdk for the
+// `eval-review` LLM grader's judge calls.
+//
+// Mirrors vally's packages/core/src/graders/llm/llm-client.ts (createCopilotLlmClient):
+// a tool-call based `judge()` API so the grader never couples to the SDK directly
+// and can be unit-tested with a fake client. The SDK (+ zod) are OPTIONAL
+// dependencies, imported dynamically here so the free, no-model static gate
+// (`review.mjs` with no --llm) never needs them installed.
+//
+// Every failure mode is surfaced as a typed Error (err.code) so callers can map
+// it to an "inconclusive" result — this grader must NEVER produce a false
+// BLOCKER because a model call could not be made.
+
+/** Error with a stable `.code` for caller-side classification. */
+export class LlmUnavailableError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "LlmUnavailableError";
+    this.code = code; // "SDK_MISSING" | "NO_TOKEN" | "START_FAILED"
+  }
+}
+
+function resolveToken() {
+  return (
+    process.env.GITHUB_COPILOT_API_TOKEN ||
+    process.env.GITHUB_TOKEN ||
+    process.env.GH_TOKEN ||
+    ""
+  );
+}
+
+/**
+ * Provision an LlmClient backed by the Copilot SDK.
+ *
+ * @returns {Promise<{ judge: Function, shutdown: Function, tokenSource: string }>}
+ * @throws {LlmUnavailableError} if the SDK isn't installed or the runtime can't start.
+ */
+export async function createCopilotLlmClient() {
+  let sdk;
+  try {
+    sdk = await import("@github/copilot-sdk");
+  } catch (err) {
+    throw new LlmUnavailableError(
+      "SDK_MISSING",
+      `@github/copilot-sdk is not installed. Install the optional deps to enable --llm ` +
+        `(cd eng/vally-graders && npm install). Original: ${err?.message ?? err}`,
+    );
+  }
+  const { CopilotClient, defineTool } = sdk;
+
+  const token = resolveToken();
+  const tokenSource = process.env.GITHUB_COPILOT_API_TOKEN
+    ? "GITHUB_COPILOT_API_TOKEN"
+    : process.env.GITHUB_TOKEN
+      ? "GITHUB_TOKEN"
+      : process.env.GH_TOKEN
+        ? "GH_TOKEN"
+        : "none";
+
+  const client = new CopilotClient({
+    env: { ...process.env, NODE_NO_WARNINGS: "1" },
+    gitHubToken: token || undefined,
+  });
+
+  try {
+    await client.start();
+  } catch (err) {
+    const hint =
+      tokenSource === "none"
+        ? " No Copilot token found (set GITHUB_COPILOT_API_TOKEN or GITHUB_TOKEN with Copilot access)."
+        : ` (token source: ${tokenSource}${
+            tokenSource === "GH_TOKEN"
+              ? "; a plain gh CLI token may lack Copilot scope"
+              : ""
+          }).`;
+    throw new LlmUnavailableError(
+      "START_FAILED",
+      `Copilot runtime failed to start.${hint} Original: ${err?.message ?? err}`,
+    );
+  }
+
+  // Deny every permission request; only the registered submit tool (which uses
+  // skipPermission) is allowed. Blocks prompt-injection from untrusted skill text.
+  const denyAll = () => ({
+    kind: "reject",
+    feedback: "eval-review judge sessions deny all tool/file access except the grading tool",
+  });
+
+  return {
+    tokenSource,
+
+    async judge(options) {
+      const start = Date.now();
+      const timeoutMs = options.timeoutMs ?? 120_000;
+      const maxReminders = options.maxReminders ?? 2;
+
+      let captured;
+      let lastValidationError;
+      let cumulativeInput = 0;
+      let cumulativeOutput = 0;
+
+      const submitTool = defineTool(options.tool.name, {
+        description: options.tool.description,
+        parameters: options.tool.parameters,
+        skipPermission: true,
+        handler: (args) => {
+          const result = options.tool.parameters.safeParse(args);
+          if (!result.success) {
+            lastValidationError = result.error.message;
+            return `Invalid arguments: ${result.error.message}`;
+          }
+          captured = result.data;
+          lastValidationError = undefined;
+          return "Review submitted. Do not respond further.";
+        },
+      });
+
+      const session = await client.createSession({
+        model: options.model,
+        systemMessage: { mode: "replace", content: options.systemMessage },
+        tools: [submitTool],
+        availableTools: [options.tool.name],
+        onPermissionRequest: denyAll,
+        infiniteSessions: { enabled: false },
+      });
+
+      session.on("tool.execution_complete", (event) => {
+        if (event?.data?.success === false) {
+          lastValidationError =
+            event.data.error?.message ?? "the SDK rejected the arguments as not matching the schema";
+        }
+      });
+      session.on("assistant.usage", (event) => {
+        cumulativeInput += event?.data?.inputTokens ?? 0;
+        cumulativeOutput += event?.data?.outputTokens ?? 0;
+      });
+
+      try {
+        await session.sendAndWait({ prompt: options.userMessage }, timeoutMs);
+
+        let remindersUsed = 0;
+        while (!captured && remindersUsed < maxReminders) {
+          const reminder = lastValidationError
+            ? `Your last \`${options.tool.name}\` call had invalid arguments: ${lastValidationError}. Call \`${options.tool.name}\` again with corrected arguments.`
+            : `You did not call \`${options.tool.name}\`. You MUST call it with your findings.`;
+          lastValidationError = undefined;
+          remindersUsed++;
+          await session.sendAndWait({ prompt: reminder }, timeoutMs);
+        }
+
+        if (!captured) {
+          throw new Error(`Judge did not invoke ${options.tool.name} after ${maxReminders} reminder(s)`);
+        }
+
+        const tokenUsage =
+          cumulativeInput + cumulativeOutput > 0
+            ? { inputTokens: cumulativeInput, outputTokens: cumulativeOutput, model: options.model }
+            : undefined;
+
+        return { args: captured, tokenUsage, latencyMs: Date.now() - start, remindersUsed };
+      } finally {
+        await session.disconnect();
+      }
+    },
+
+    async shutdown() {
+      try {
+        await client.stop();
+      } catch {
+        /* best effort */
+      }
+    },
+  };
+}
diff --git a/eng/vally-graders/lib/locate.mjs b/eng/vally-graders/lib/locate.mjs
new file mode 100644
index 0000000000..8173facecd
--- /dev/null
+++ b/eng/vally-graders/lib/locate.mjs
@@ -0,0 +1,324 @@
+// locate.mjs — skill <-> eval discovery and parsing.
+//
+// Repo conventions (dotnet/skills):
+//   skill:  plugins/<plugin>/skills/<name>/SKILL.md
+//   agent:  plugins/<plugin>/agents/<name>.agent.md
+//   eval:   tests/<plugin>/<name>/eval.yaml          (native skill-validator format)
+//           tests/<plugin>/<name>/eval.vally.yaml     (vally-native adapted twin)
+//           tests/<plugin>/agent.<name>/...           (evals for an agent)
+//   fixtures: tests/<plugin>/<name>/fixtures/**       (optional)
+//
+// Discovery is layered and loud on ambiguity: we resolve by convention and
+// attach a `notes[]` array to each unit describing anything unexpected (no eval,
+// no skill doc, multiple eval files) so callers can surface it instead of
+// silently dropping a unit.
+
+import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { join, relative, sep, basename, dirname } from "node:path";
+import yaml from "js-yaml";
+
+const EVAL_FILENAMES = ["eval.yaml", "eval.vally.yaml", "eval.yml"];
+
+function toPosix(p) {
+  return p.split(sep).join("/");
+}
+
+function readText(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function isDir(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function listDirs(path) {
+  try {
+    return readdirSync(path, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+
+/** Recursively list files under a directory, returning repo-relative posix paths. */
+function walkFiles(root, dir, acc = []) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return acc;
+  }
+  for (const e of entries) {
+    const full = join(dir, e.name);
+    if (e.isDirectory()) walkFiles(root, full, acc);
+    else if (e.isFile()) acc.push(toPosix(relative(root, full)));
+  }
+  return acc;
+}
+
+/**
+ * Parse a native eval.yaml (skill-validator schema) or eval.vally.yaml into a
+ * normalized shape:
+ *   { format: "native"|"vally"|"unknown", scenarios: [{ name, prompt,
+ *     expectActivation, assertionTypes: string[], assertions: object[],
+ *     rubric: string[], setupFiles: [{path, hasSource, hasContent, content}] }],
+ *     parseError }
+ */
+export function parseEvalFile(path) {
+  const text = readText(path);
+  if (text == null) return { format: "unknown", scenarios: [], parseError: "unreadable", text: "" };
+  let doc;
+  try {
+    doc = yaml.load(text);
+  } catch (err) {
+    return { format: "unknown", scenarios: [], parseError: String(err?.message ?? err), text };
+  }
+  if (!doc || typeof doc !== "object") {
+    return { format: "unknown", scenarios: [], parseError: "empty or non-object document", text };
+  }
+
+  // Native skill-validator format: top-level `scenarios:`.
+  if (Array.isArray(doc.scenarios)) {
+    const scenarios = doc.scenarios.map((s) => normalizeNativeScenario(s));
+    return { format: "native", scenarios, parseError: null, text };
+  }
+  // Vally-native format: top-level `stimuli:` with per-stimulus `graders:`.
+  if (Array.isArray(doc.stimuli)) {
+    const scenarios = doc.stimuli.map((s) => normalizeVallyStimulus(s));
+    return { format: "vally", scenarios, parseError: null, text };
+  }
+  return { format: "unknown", scenarios: [], parseError: "no scenarios/stimuli key", text };
+}
+
+function normalizeNativeScenario(s) {
+  const assertions = Array.isArray(s?.assertions) ? s.assertions : [];
+  const setup = s?.setup ?? {};
+  const files = Array.isArray(setup.files) ? setup.files : [];
+  return {
+    name: s?.name ?? "",
+    prompt: typeof s?.prompt === "string" ? s.prompt : "",
+    expectActivation: s?.expect_activation !== false, // default true unless explicitly false
+    hasExpectActivationFalse: s?.expect_activation === false,
+    assertionTypes: assertions.map((a) => a?.type).filter(Boolean),
+    assertions,
+    rubric: Array.isArray(s?.rubric) ? s.rubric : [],
+    copyTestFiles: setup.copy_test_files === true,
+    setupCommands: Array.isArray(setup.commands) ? setup.commands : [],
+    setupFiles: files.map((f) => ({
+      path: f?.path ?? "",
+      source: f?.source ?? null,
+      hasSource: typeof f?.source === "string",
+      hasContent: typeof f?.content === "string",
+      content: typeof f?.content === "string" ? f.content : null,
+    })),
+  };
+}
+
+function normalizeVallyStimulus(s) {
+  const graders = Array.isArray(s?.graders) ? s.graders : [];
+  return {
+    name: s?.name ?? "",
+    prompt: typeof s?.prompt === "string" ? s.prompt : "",
+    expectActivation: true,
+    hasExpectActivationFalse: false,
+    // Map vally grader `type`s onto the native assertion vocabulary so downstream
+    // graders can reason uniformly.
+    assertionTypes: graders.map((g) => vallyGraderToAssertionType(g?.type)).filter(Boolean),
+    assertions: graders,
+    rubric: Array.isArray(s?.rubric) ? s.rubric : [],
+    copyTestFiles: false,
+    setupCommands: [],
+    setupFiles: [],
+  };
+}
+
+function vallyGraderToAssertionType(type) {
+  switch (type) {
+    case "output-contains":
+      return "output_contains";
+    case "output-matches":
+      return "output_matches";
+    case "file-contains":
+      return "file_contains";
+    case "command":
+    case "run-command":
+      return "run_command_and_assert";
+    default:
+      return type; // "prompt", etc.
+  }
+}
+
+// Assertion types that verify a concrete RESULT (checklist B: hard gate).
+const HARD_GATE_TYPES = new Set([
+  "run_command_and_assert",
+  "file_contains",
+  "file_not_contains",
+  "file_exists",
+  "file_not_exists",
+  "exit_success",
+]);
+
+export function isHardGate(assertionType) {
+  return HARD_GATE_TYPES.has(assertionType);
+}
+
+/**
+ * Resolve the skill/agent doc that owns an eval directory.
+ * Returns { skillDoc, skillDir, kind } or nulls if not found.
+ */
+function resolveSkillDoc(repoRoot, plugin, evalName) {
+  // Agent evals live under tests/<plugin>/agent.<name>/ and map to
+  // plugins/<plugin>/agents/<name>.agent.md.
+  if (evalName.startsWith("agent.")) {
+    const agentName = evalName.slice("agent.".length);
+    const doc = join(repoRoot, "plugins", plugin, "agents", `${agentName}.agent.md`);
+    if (existsSync(doc)) return { skillDoc: doc, skillDir: dirname(doc), kind: "agent" };
+    return { skillDoc: null, skillDir: null, kind: "agent" };
+  }
+  const skillDir = join(repoRoot, "plugins", plugin, "skills", evalName);
+  const doc = join(skillDir, "SKILL.md");
+  if (existsSync(doc)) return { skillDoc: doc, skillDir, kind: "skill" };
+  return { skillDoc: null, skillDir: isDir(skillDir) ? skillDir : null, kind: "skill" };
+}
+
+/** Build a unit from an eval directory (tests/<plugin>/<name>). */
+export function unitFromEvalDir(repoRoot, evalDirAbs) {
+  const rel = toPosix(relative(repoRoot, evalDirAbs)); // tests/<plugin>/<name>
+  const parts = rel.split("/");
+  const plugin = parts[1] ?? "";
+  const name = parts[2] ?? basename(evalDirAbs);
+  const notes = [];
+
+  const evalFiles = [];
+  for (const fn of EVAL_FILENAMES) {
+    const p = join(evalDirAbs, fn);
+    if (existsSync(p)) {
+      const parsed = parseEvalFile(p);
+      evalFiles.push({ path: toPosix(relative(repoRoot, p)), abs: p, parsed });
+    }
+  }
+  if (evalFiles.length === 0) notes.push(`no eval file found in ${rel}`);
+
+  const { skillDoc, skillDir, kind } = resolveSkillDoc(repoRoot, plugin, name);
+  if (!skillDoc) notes.push(`no skill/agent doc resolved for ${plugin}/${name}`);
+
+  const fixturesAbs = join(evalDirAbs, "fixtures");
+  const fixtures = isDir(fixturesAbs) ? walkFiles(repoRoot, fixturesAbs) : [];
+
+  return {
+    repoRoot,
+    plugin,
+    name,
+    kind,
+    evalDir: rel,
+    evalDirAbs,
+    evalFiles,
+    skillDoc: skillDoc ? toPosix(relative(repoRoot, skillDoc)) : null,
+    skillDocAbs: skillDoc,
+    skillDocText: skillDoc ? readText(skillDoc) : null,
+    skillDir: skillDir ? toPosix(relative(repoRoot, skillDir)) : null,
+    fixtures,
+    notes,
+  };
+}
+
+/** Enumerate every eval directory under tests/. */
+export function findEvalDirs(repoRoot) {
+  const testsRoot = join(repoRoot, "tests");
+  const result = [];
+  for (const plugin of listDirs(testsRoot)) {
+    const pluginDir = join(testsRoot, plugin);
+    for (const name of listDirs(pluginDir)) {
+      const evalDir = join(pluginDir, name);
+      if (EVAL_FILENAMES.some((fn) => existsSync(join(evalDir, fn)))) {
+        result.push(evalDir);
+      }
+    }
+  }
+  return result;
+}
+
+/** All units in the repo. */
+export function allUnits(repoRoot) {
+  return findEvalDirs(repoRoot).map((d) => unitFromEvalDir(repoRoot, d));
+}
+
+/**
+ * Map a set of changed repo-relative files to the units they touch, walking
+ * both directions (eval/fixture -> unit, and skill/agent doc -> unit).
+ */
+export function unitsFromChangedFiles(repoRoot, changedFiles) {
+  const evalDirKeys = new Set();
+  const addByPluginName = (plugin, name) => {
+    if (!plugin || !name) return;
+    const evalDir = join(repoRoot, "tests", plugin, name);
+    if (EVAL_FILENAMES.some((fn) => existsSync(join(evalDir, fn)))) {
+      evalDirKeys.add(toPosix(relative(repoRoot, evalDir)));
+    }
+  };
+
+  for (const raw of changedFiles) {
+    const f = toPosix(raw).replace(/^\.\//, "");
+    const parts = f.split("/");
+    if (parts[0] === "tests" && parts.length >= 3) {
+      // tests/<plugin>/<name>/...  (covers eval files and fixtures)
+      addByPluginName(parts[1], parts[2]);
+    } else if (parts[0] === "plugins" && parts[2] === "skills" && parts.length >= 4) {
+      // plugins/<plugin>/skills/<name>/...
+      addByPluginName(parts[1], parts[3]);
+    } else if (parts[0] === "plugins" && parts[2] === "agents" && parts.length >= 4) {
+      // plugins/<plugin>/agents/<name>.agent.md -> tests/<plugin>/agent.<name>
+      const agentFile = parts[3];
+      const m = /^(.*)\.agent\.md$/.exec(agentFile);
+      if (m) addByPluginName(parts[1], `agent.${m[1]}`);
+    }
+  }
+
+  return [...evalDirKeys]
+    .sort()
+    .map((rel) => unitFromEvalDir(repoRoot, join(repoRoot, ...rel.split("/"))));
+}
+
+/**
+ * Build units from Vally skill directories (GraderInput.stimulus.environment.skills).
+ * Each entry is a skill dir like plugins/<plugin>/skills/<name>; we recover the
+ * plugin/name and delegate to the eval-dir resolver.
+ */
+export function unitsFromSkillDirs(repoRoot, skillDirs) {
+  const units = [];
+  for (const sd of skillDirs) {
+    const rel = toPosix(relative(repoRoot, sd)).replace(/^\.\//, "");
+    const parts = rel.split("/");
+    let plugin;
+    let name;
+    if (parts[0] === "plugins" && parts[2] === "skills") {
+      plugin = parts[1];
+      name = parts[3];
+    } else if (parts[0] === "plugins" && parts[2] === "agents") {
+      plugin = parts[1];
+      const m = /^(.*)\.agent\.md$/.exec(parts[3] ?? "");
+      name = m ? `agent.${m[1]}` : parts[3];
+    } else {
+      // Fall back to the last two path segments.
+      plugin = parts[parts.length - 2];
+      name = parts[parts.length - 1];
+    }
+    const evalDir = join(repoRoot, "tests", plugin, name);
+    units.push(unitFromEvalDir(repoRoot, evalDir));
+  }
+  return units;
+}
+
+/** Read a repo file's text (repo-relative posix path). */
+export function readRepoFile(repoRoot, relPath) {
+  return readText(join(repoRoot, ...relPath.split("/")));
+}
diff --git a/eng/vally-graders/lib/report.mjs b/eng/vally-graders/lib/report.mjs
new file mode 100644
index 0000000000..9c25decf7a
--- /dev/null
+++ b/eng/vally-graders/lib/report.mjs
@@ -0,0 +1,128 @@
+// report.mjs — finding model, [SEVERITY]/PROOF/WHY/FIX formatting, and verdict.
+//
+// A Finding is the atomic output of every grader. Severities follow the review
+// checklist: BLOCKER > MAJOR > MINOR > INFO. INFO never affects the verdict and
+// never fails the gate.
+//
+// Evidence-based severity rule (per cross-family review): a MAJOR/BLOCKER MUST
+// carry a concrete proof (quoted file:line text). `finding()` enforces this —
+// a blocking severity with no proof is automatically downgraded to MINOR.
+
+export const SEVERITY = Object.freeze({
+  BLOCKER: "BLOCKER",
+  MAJOR: "MAJOR",
+  MINOR: "MINOR",
+  INFO: "INFO",
+});
+
+const SEVERITY_RANK = { BLOCKER: 3, MAJOR: 2, MINOR: 1, INFO: 0 };
+
+// Severities that fail the gate / flip a Vally grader to passed:false.
+export function isBlocking(severity) {
+  return severity === SEVERITY.BLOCKER || severity === SEVERITY.MAJOR;
+}
+
+/**
+ * Build a finding. Enforces the evidence rule: a BLOCKER/MAJOR without a proof
+ * string is downgraded to MINOR so we never fail a build on an unproven claim.
+ *
+ * @param {object} f
+ * @param {string} f.severity   one of SEVERITY.*
+ * @param {string} f.dimension  short dimension id, e.g. "assertion-hardening"
+ * @param {string} f.file       repo-relative file path (proof location)
+ * @param {number|null} [f.line] 1-based line number, or null
+ * @param {string} [f.proof]    exact quoted text at file:line
+ * @param {string} f.why        why this matters
+ * @param {string} f.fix        concrete suggested fix
+ * @param {string} [f.rule]     checklist rule id, e.g. "B1"
+ */
+export function finding(f) {
+  let severity = f.severity;
+  const hasProof = typeof f.proof === "string" && f.proof.trim().length > 0;
+  if (isBlocking(severity) && !hasProof) {
+    severity = SEVERITY.MINOR;
+  }
+  return {
+    severity,
+    dimension: f.dimension,
+    file: f.file ?? null,
+    line: f.line ?? null,
+    proof: hasProof ? f.proof.trim() : null,
+    why: f.why ?? "",
+    fix: f.fix ?? "",
+    rule: f.rule ?? null,
+  };
+}
+
+/** 1-based line number of the first line containing `needle`, or null. */
+export function lineOf(text, needle) {
+  if (!text || !needle) return null;
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(needle)) return i + 1;
+  }
+  return null;
+}
+
+/** The raw text of a given 1-based line, trimmed, or "". */
+export function textOfLine(text, line) {
+  if (!text || !line) return "";
+  const lines = text.split("\n");
+  return (lines[line - 1] ?? "").trim();
+}
+
+/** Highest severity present in a set of findings (INFO if empty). */
+export function maxSeverity(findings) {
+  let max = SEVERITY.INFO;
+  for (const f of findings) {
+    if (SEVERITY_RANK[f.severity] > SEVERITY_RANK[max]) max = f.severity;
+  }
+  return max;
+}
+
+/**
+ * Verdict from findings (matches the checklist verdict axis):
+ *   Rework        — any BLOCKER open.
+ *   Fix-then-ship — any MAJOR or MINOR open (no BLOCKER).
+ *   Ship          — no BLOCKER/MAJOR/MINOR (INFO only, or nothing).
+ */
+export function verdict(findings) {
+  const max = maxSeverity(findings);
+  if (max === SEVERITY.BLOCKER) return "Rework";
+  if (max === SEVERITY.MAJOR || max === SEVERITY.MINOR) return "Fix-then-ship";
+  return "Ship";
+}
+
+function locLabel(f) {
+  if (!f.file) return "(no location)";
+  return f.line ? `${f.file}:${f.line}` : f.file;
+}
+
+/** Render a single finding in the [SEVERITY] dimension — file:line shape. */
+export function formatFinding(f) {
+  const rule = f.rule ? ` (${f.rule})` : "";
+  const lines = [`[${f.severity}] ${f.dimension}${rule} — ${locLabel(f)}`];
+  if (f.proof) lines.push(`  PROOF: ${JSON.stringify(f.proof)}`);
+  if (f.why) lines.push(`  WHY:   ${f.why}`);
+  if (f.fix) lines.push(`  FIX:   ${f.fix}`);
+  return lines.join("\n");
+}
+
+/** Count findings by severity. */
+export function severityCounts(findings) {
+  const counts = { BLOCKER: 0, MAJOR: 0, MINOR: 0, INFO: 0 };
+  for (const f of findings) counts[f.severity]++;
+  return counts;
+}
+
+/** Render a full report block for one unit. */
+export function formatUnitReport(unitLabel, findings) {
+  const lines = [`### ${unitLabel}`];
+  if (findings.length === 0) {
+    lines.push("  (no findings)");
+  } else {
+    for (const f of findings) lines.push(formatFinding(f));
+  }
+  lines.push(`  VERDICT: ${verdict(findings)}`);
+  return lines.join("\n");
+}
diff --git a/eng/vally-graders/package-lock.json b/eng/vally-graders/package-lock.json
new file mode 100644
index 0000000000..aba5c90f9c
--- /dev/null
+++ b/eng/vally-graders/package-lock.json
@@ -0,0 +1,247 @@
+{
+  "name": "@dotnet-skills/vally-graders",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@dotnet-skills/vally-graders",
+      "version": "0.1.0",
+      "license": "MIT",
+      "dependencies": {
+        "js-yaml": "^4.1.0"
+      },
+      "bin": {
+        "eval-review": "review.mjs"
+      },
+      "optionalDependencies": {
+        "@github/copilot-sdk": "^1.0.0-beta.8",
+        "zod": "^4.4.3"
+      }
+    },
+    "node_modules/@github/copilot": {
+      "version": "1.0.71",
+      "resolved": "https://registry.npmjs.org/@github/copilot/-/copilot-1.0.71.tgz",
+      "integrity": "sha512-F3axBi+sXSLYDJbxCBW36bM6MYKNC2rlyAf3Ivo/MjiHKKJW7j5AmaR1IRYS9Gt8r9mxOwWFM1cJFA+CuLaR8g==",
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "dependencies": {
+        "detect-libc": "^2.1.2"
+      },
+      "bin": {
+        "copilot": "npm-loader.js"
+      },
+      "optionalDependencies": {
+        "@github/copilot-darwin-arm64": "1.0.71",
+        "@github/copilot-darwin-x64": "1.0.71",
+        "@github/copilot-linux-arm64": "1.0.71",
+        "@github/copilot-linux-x64": "1.0.71",
+        "@github/copilot-linuxmusl-arm64": "1.0.71",
+        "@github/copilot-linuxmusl-x64": "1.0.71",
+        "@github/copilot-win32-arm64": "1.0.71",
+        "@github/copilot-win32-x64": "1.0.71"
+      }
+    },
+    "node_modules/@github/copilot-darwin-arm64": {
+      "version": "1.0.71",
+      "resolved": "https://registry.npmjs.org/@github/copilot-darwin-arm64/-/copilot-darwin-arm64-1.0.71.tgz",
+      "integrity": "sha512-mEWzyqbqRAWgyU7i2uuSRoVPx/TwaFQX0nZmw0bc30aJ0BnO7cy2kYQyCHw8ykmf/tfxT0xauZ6k0BOFmWizzQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "bin": {
+        "copilot-darwin-arm64": "copilot"
+      }
+    },
+    "node_modules/@github/copilot-darwin-x64": {
+      "version": "1.0.71",
+      "resolved": "https://registry.npmjs.org/@github/copilot-darwin-x64/-/copilot-darwin-x64-1.0.71.tgz",
+      "integrity": "sha512-Md9yEg406OBVBx3w4PeEj62TubulVLBcHleqmCoOoUmPgUxPZotUbrqz3rtbzADbXfrrD7JWvVsbd2UiNL194w==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "bin": {
+        "copilot-darwin-x64": "copilot"
+      }
+    },
+    "node_modules/@github/copilot-linux-arm64": {
+      "version": "1.0.71",
+      "resolved": "https://registry.npmjs.org/@github/copilot-linux-arm64/-/copilot-linux-arm64-1.0.71.tgz",
+      "integrity": "sha512-ykLJYOqBj3jRB5IJCDugLClAqbr7DmtTbUjlNY7+Jdq/n6i+d7xUQGclf1IWL5gnxbGQVAf+zkToD+sRM389Kg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "bin": {
+        "copilot-linux-arm64": "copilot"
+      }
+    },
+    "node_modules/@github/copilot-linux-x64": {
+      "version": "1.0.71",
+      "resolved": "https://registry.npmjs.org/@github/copilot-linux-x64/-/copilot-linux-x64-1.0.71.tgz",
+      "integrity": "sha512-pC0FNHG+BBwZd6yZlM85kkAGN+uJhM6o+THi76N2GnnSxmw7+remb1mvYxdgRVbdCm+LBUIbCKRWJLuMwrfb6A==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "bin": {
+        "copilot-linux-x64": "copilot"
+      }
+    },
+    "node_modules/@github/copilot-linuxmusl-arm64": {
+      "version": "1.0.71",
+      "resolved": "https://registry.npmjs.org/@github/copilot-linuxmusl-arm64/-/copilot-linuxmusl-arm64-1.0.71.tgz",
+      "integrity": "sha512-hBmDljFTjacxqZTasCEy43H8EIzuXB/hHEBBCMFjhB9J00nIxsO6Dh0woTifKpx7knTYZdpTjjca3D0pAoZlUA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "bin": {
+        "copilot-linuxmusl-arm64": "copilot"
+      }
+    },
+    "node_modules/@github/copilot-linuxmusl-x64": {
+      "version": "1.0.71",
+      "resolved": "https://registry.npmjs.org/@github/copilot-linuxmusl-x64/-/copilot-linuxmusl-x64-1.0.71.tgz",
+      "integrity": "sha512-CfTXU8pa5dxRz22xQzoi3TiG1PJo9+WR8PRDiPSdkIBSyPJ1NvX87DJmfXjTgeAfR+wkjt/p0keDCaBBVhNmUA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "bin": {
+        "copilot-linuxmusl-x64": "copilot"
+      }
+    },
+    "node_modules/@github/copilot-sdk": {
+      "version": "1.0.0-beta.8",
+      "resolved": "https://registry.npmjs.org/@github/copilot-sdk/-/copilot-sdk-1.0.0-beta.8.tgz",
+      "integrity": "sha512-lAuBfH6E5PUaSj8P/0FVMxzvwwBUs02tlvQ56PoJFtuc47KPqzGpf9BS7+h2eEr1UmjoLNJ/yqDiVApH9Oo1Fg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@github/copilot": "^1.0.55-1",
+        "vscode-jsonrpc": "^8.2.1",
+        "zod": "^4.3.6"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@github/copilot-win32-arm64": {
+      "version": "1.0.71",
+      "resolved": "https://registry.npmjs.org/@github/copilot-win32-arm64/-/copilot-win32-arm64-1.0.71.tgz",
+      "integrity": "sha512-+HI1DokixXhHUahj06Fw67ZAigBuXKC58BFma4UJOGrQsDgwOSbqeTQHCw6vuymzjKlg3sactfsCUTaefkjscQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "bin": {
+        "copilot-win32-arm64": "copilot.exe"
+      }
+    },
+    "node_modules/@github/copilot-win32-x64": {
+      "version": "1.0.71",
+      "resolved": "https://registry.npmjs.org/@github/copilot-win32-x64/-/copilot-win32-x64-1.0.71.tgz",
+      "integrity": "sha512-02kXOBd9CwBbCaztuf71WYWn+uGapCuiaasomN4tcMH3HBVZ4gi3J0ZUoRcgcS80xh81uQyeBHbnUKzb/RE/9A==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "bin": {
+        "copilot-win32-x64": "copilot.exe"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "license": "Python-2.0"
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/js-yaml": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.0.tgz",
+      "integrity": "sha512-1td788aAnnZ5qs7V2QIRl1owjtYpbKt749Y3xauqQgwIIGF/xXWz1wMTEBx5O3LK3lXLVuqXPdPxj2BoFHaW9Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/puzrin"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodeca"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/vscode-jsonrpc": {
+      "version": "8.2.1",
+      "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.1.tgz",
+      "integrity": "sha512-kdjOSJ2lLIn7r1rtrMbbNCHjyMPfRnowdKjBQ+mGq6NAW5QY2bEZC/khaC5OR8svbbjvLEaIXkOq45e2X9BIbQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
+      "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+      "license": "MIT",
+      "optional": true,
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}
diff --git a/eng/vally-graders/package.json b/eng/vally-graders/package.json
new file mode 100644
index 0000000000..5486e7e898
--- /dev/null
+++ b/eng/vally-graders/package.json
@@ -0,0 +1,27 @@
+{
+  "name": "@dotnet-skills/vally-graders",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Repo-local skill/eval quality graders (eval-review). Runs as a standalone per-PR gate and is also Vally grader-plugin compatible.",
+  "type": "module",
+  "main": "index.mjs",
+  "exports": {
+    ".": "./index.mjs",
+    "./review": "./review.mjs"
+  },
+  "bin": {
+    "eval-review": "./review.mjs"
+  },
+  "scripts": {
+    "test": "node --test",
+    "review": "node review.mjs"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "license": "MIT",
+  "optionalDependencies": {
+    "@github/copilot-sdk": "^1.0.0-beta.8",
+    "zod": "^4.4.3"
+  }
+}
diff --git a/eng/vally-graders/review.mjs b/eng/vally-graders/review.mjs
new file mode 100644
index 0000000000..f55ef8bb84
--- /dev/null
+++ b/eng/vally-graders/review.mjs
@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+// review.mjs — standalone skill/eval quality gate.
+//
+// This is the REAL enforcement path (see README): it runs the free static
+// graders over changed (default) or all skill+eval units, prints
+// [SEVERITY]/PROOF/WHY/FIX findings, and exits nonzero when a blocking finding
+// is present.
+//
+// Opt-in LLM review: with --llm it ALSO runs the `eval-review` judge-model
+// grader (fixture honesty C, design balance D1–D3, domain-correctness DC). That
+// path costs money/latency, so it is off by default and is NOT part of the free
+// per-PR CI gate. If the model/token/SDK are unavailable it reports the unit as
+// inconclusive (never a false failure).
+//
+// Usage:
+//   node review.mjs [--all] [--base <ref>] [--unit <substr>]... \
+//     [--report-only <dimension>]... [--fail-on BLOCKER|MAJOR|MINOR] [--json] \
+//     [--llm [--model <id>]]
+//
+// Default (no --all): evaluate only the units touched by the PR/working tree,
+// determined from `git diff` against --base (or GITHUB_BASE_REF / main).
+
+import { execFileSync } from "node:child_process";
+import { parseArgs } from "node:util";
+
+import { staticModules, llmModule } from "./index.mjs";
+import { allUnits, unitsFromChangedFiles } from "./lib/locate.mjs";
+import {
+  formatUnitReport,
+  severityCounts,
+  verdict,
+  isBlocking,
+} from "./lib/report.mjs";
+
+const SEVERITY_RANK = { BLOCKER: 3, MAJOR: 2, MINOR: 1, INFO: 0 };
+
+const { values: opts } = parseArgs({
+  options: {
+    all: { type: "boolean", default: false },
+    base: { type: "string" },
+    unit: { type: "string", multiple: true, default: [] },
+    "report-only": { type: "string", multiple: true, default: [] },
+    "fail-on": { type: "string", default: "MAJOR" },
+    "repo-root": { type: "string" },
+    json: { type: "boolean", default: false },
+    llm: { type: "boolean", default: false },
+    model: { type: "string" },
+    help: { type: "boolean", default: false },
+  },
+  strict: true,
+});
+
+if (opts.help) {
+  console.log(`eval-review — skill/eval quality gate (free static graders + opt-in LLM review)
+
+Usage:
+  node review.mjs [options]
+
+Options:
+  --all                     Evaluate every skill+eval unit in the repo.
+  --base <ref>              Git base ref for changed-file detection
+                            (default: GITHUB_BASE_REF or 'main').
+  --unit <substr>           Only units whose "<plugin>/<name>" contains <substr>
+                            (repeatable). Implies scanning all units first.
+  --report-only <dim>       Downgrade findings from <dimension> to non-blocking
+                            (still printed). Repeatable. e.g. eval-deleading.
+  --fail-on <severity>      Minimum blocking severity (BLOCKER|MAJOR|MINOR).
+                            Default: MAJOR.
+  --repo-root <path>        Repo root (default: git toplevel or cwd).
+  --json                    Emit machine-readable JSON instead of text.
+  --llm                     ALSO run the eval-review judge-model grader
+                            (fixture honesty C, design balance D1-D3,
+                            domain-correctness DC). Costs money/latency; needs a
+                            Copilot token + @github/copilot-sdk. Off by default;
+                            NOT part of the free CI gate.
+  --model <id>              Judge model for --llm (default: EVAL_REVIEW_MODEL env
+                            or 'claude-opus-4.6').
+  --help                    Show this help.`);
+  process.exit(0);
+}
+
+function repoRoot() {
+  if (opts["repo-root"]) return opts["repo-root"];
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+
+function isGitHub() {
+  return process.env.GITHUB_ACTIONS === "true";
+}
+
+function changedFiles(root, base) {
+  const files = new Set();
+  const run = (args) => {
+    try {
+      const out = execFileSync("git", args, { cwd: root, encoding: "utf-8" });
+      for (const l of out.split("\n")) {
+        const t = l.trim();
+        if (t) files.add(t);
+      }
+    } catch {
+      /* ignore — best effort */
+    }
+  };
+  // Committed changes since the merge-base with base.
+  run(["diff", "--name-only", `${base}...HEAD`]);
+  // Uncommitted (working tree) changes, for local runs.
+  run(["diff", "--name-only", "HEAD"]);
+  run(["diff", "--name-only", "--staged"]);
+  return [...files];
+}
+
+function selectUnits(root) {
+  if (opts.all || opts.unit.length > 0) {
+    let units = allUnits(root);
+    if (opts.unit.length > 0) {
+      units = units.filter((u) =>
+        opts.unit.some((s) => `${u.plugin}/${u.name}`.includes(s)),
+      );
+    }
+    return units;
+  }
+  const base = opts.base ?? process.env.GITHUB_BASE_REF ?? "main";
+  const files = changedFiles(root, base);
+  return unitsFromChangedFiles(root, files);
+}
+
+function ghAnnotate(f) {
+  if (!isGitHub()) return;
+  const level = isBlocking(f.severity) ? "error" : "warning";
+  const loc = f.file ? `file=${f.file}${f.line ? `,line=${f.line}` : ""}` : "";
+  const msg = `[${f.dimension}${f.rule ? ` ${f.rule}` : ""}] ${f.why}${f.fix ? ` FIX: ${f.fix}` : ""}`;
+  console.log(`::${level} ${loc}::${msg.replace(/\n/g, " ")}`);
+}
+
+async function runLlm(units, root) {
+  // Provision one client for all units; report inconclusive (never fail) if the
+  // SDK/token/runtime aren't available.
+  const model = opts.model || llmModule.DEFAULT_MODEL;
+  const results = new Map(); // unit -> { findings, inconclusive, reason }
+  let client;
+  const { createCopilotLlmClient, LlmUnavailableError } = await import("./lib/llm-client.mjs");
+  try {
+    client = await createCopilotLlmClient();
+  } catch (err) {
+    const reason =
+      err instanceof LlmUnavailableError ? err.message : `could not provision llm client: ${err?.message ?? err}`;
+    console.error(`⚠ eval-review --llm inconclusive for all units: ${reason}`);
+    for (const unit of units) results.set(unit, { findings: [], inconclusive: true, reason });
+    return { results, model, clientReason: reason };
+  }
+  try {
+    for (const unit of units) {
+      const r = await llmModule.reviewUnit(unit, { client, model });
+      results.set(unit, {
+        findings: r.findings ?? [],
+        inconclusive: Boolean(r.inconclusive),
+        reason: r.reason ?? null,
+        usage: r.usage ?? null,
+      });
+    }
+  } finally {
+    if (client?.shutdown) await client.shutdown();
+  }
+  return { results, model, clientReason: null };
+}
+
+async function main() {
+  const root = repoRoot();
+  const reportOnly = new Set(opts["report-only"]);
+  const failRank = SEVERITY_RANK[opts["fail-on"]] ?? SEVERITY_RANK.MAJOR;
+
+  const units = selectUnits(root);
+
+  // Optional LLM pass (opt-in): provision once, review each unit.
+  let llm = null;
+  if (opts.llm && units.length > 0) {
+    llm = await runLlm(units, root);
+  }
+
+  const perUnit = [];
+  const allFindings = [];
+
+  for (const unit of units) {
+    const findings = [];
+    for (const mod of staticModules) {
+      try {
+        findings.push(...mod.review(unit));
+      } catch (err) {
+        console.error(`⚠ ${mod.metadata.name} failed on ${unit.plugin}/${unit.name}: ${err?.message ?? err}`);
+      }
+    }
+    const llmNotes = [];
+    if (llm) {
+      const r = llm.results.get(unit);
+      if (r) {
+        findings.push(...r.findings);
+        if (r.inconclusive) llmNotes.push(`eval-review (llm) inconclusive: ${r.reason}`);
+      }
+    }
+    // Blocking = severity >= fail-on AND dimension not in report-only.
+    const blocking = findings.filter(
+      (f) => SEVERITY_RANK[f.severity] >= failRank && !reportOnly.has(f.dimension),
+    );
+    perUnit.push({ unit, findings, blocking, llmNotes });
+    allFindings.push(...findings);
+    for (const f of findings) ghAnnotate(f);
+  }
+
+  const blockingTotal = perUnit.reduce((n, u) => n + u.blocking.length, 0);
+
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          repoRoot: root,
+          unitCount: units.length,
+          llm: llm ? { enabled: true, model: llm.model } : { enabled: false },
+          counts: severityCounts(allFindings),
+          blocking: blockingTotal,
+          verdict: verdict(allFindings),
+          units: perUnit.map((u) => ({
+            unit: `${u.unit.plugin}/${u.unit.name}`,
+            skillDoc: u.unit.skillDoc,
+            evalFiles: u.unit.evalFiles.map((e) => e.path),
+            notes: u.unit.notes,
+            llmNotes: u.llmNotes,
+            findings: u.findings,
+            blocking: u.blocking.length,
+            verdict: verdict(u.findings),
+          })),
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    printText(root, units, perUnit, allFindings, reportOnly, blockingTotal, llm);
+  }
+
+  process.exitCode = blockingTotal > 0 ? 1 : 0;
+}
+
+function printText(root, units, perUnit, allFindings, reportOnly, blockingTotal, llm) {
+  const banner = llm ? `eval-review (static + llm:${llm.model})` : "eval-review (static)";
+  console.log(`${banner} — ${units.length} unit(s) evaluated (root: ${root})\n`);
+  if (units.length === 0) {
+    console.log("No skill+eval units selected. (No matching changes, or use --all.)");
+    return;
+  }
+  for (const { unit, findings, llmNotes } of perUnit) {
+    const label = `${unit.plugin}/${unit.name}` + (unit.evalFiles.length ? "" : " (no eval)");
+    // Only print units that have something to say, unless --all.
+    if (findings.length === 0 && unit.notes.length === 0 && llmNotes.length === 0 && !opts.all) continue;
+    console.log(formatUnitReport(label, findings));
+    for (const note of unit.notes) console.log(`  NOTE:  ${note}`);
+    for (const note of llmNotes) console.log(`  NOTE:  ${note}`);
+    console.log("");
+  }
+  const counts = severityCounts(allFindings);
+  const roNote = reportOnly.size ? ` (report-only: ${[...reportOnly].join(", ")})` : "";
+  console.log(
+    `Summary: ${counts.BLOCKER} BLOCKER, ${counts.MAJOR} MAJOR, ${counts.MINOR} MINOR, ${counts.INFO} INFO${roNote}`,
+  );
+  console.log(`Overall verdict: ${verdict(allFindings)}`);
+  console.log(
+    blockingTotal > 0
+      ? `\n✗ ${blockingTotal} blocking finding(s) at or above ${opts["fail-on"]}. Failing.`
+      : `\n✓ No blocking findings at or above ${opts["fail-on"]}.`,
+  );
+}
+
+main().catch((err) => {
+  console.error(`eval-review: fatal error: ${err?.stack ?? err}`);
+  process.exitCode = 1;
+});
diff --git a/eng/vally-graders/tests/fixtures/repo/plugins/demo/skills/clean-skill/SKILL.md b/eng/vally-graders/tests/fixtures/repo/plugins/demo/skills/clean-skill/SKILL.md
new file mode 100644
index 0000000000..331a70dd28
--- /dev/null
+++ b/eng/vally-graders/tests/fixtures/repo/plugins/demo/skills/clean-skill/SKILL.md
@@ -0,0 +1,13 @@
+---
+name: clean-skill
+description: Demonstration skill whose evals are hardened (test fixture).
+---
+
+# clean-skill
+
+USE FOR: exercising the eval-review graders' false-positive guards.
+DO NOT USE FOR: diagnosing runtime crashes (use crash-doctor instead).
+
+## Guidance
+
+State the rule, not how it was derived.
diff --git a/eng/vally-graders/tests/fixtures/repo/plugins/demo/skills/leaky-skill/SKILL.md b/eng/vally-graders/tests/fixtures/repo/plugins/demo/skills/leaky-skill/SKILL.md
new file mode 100644
index 0000000000..5f7838f9b8
--- /dev/null
+++ b/eng/vally-graders/tests/fixtures/repo/plugins/demo/skills/leaky-skill/SKILL.md
@@ -0,0 +1,15 @@
+---
+name: leaky-skill
+description: Demonstration skill with deliberately leaky evals (test fixture).
+---
+
+# leaky-skill
+
+USE FOR: exercising the eval-review graders in tests.
+DO NOT USE FOR: creating brand-new widgets (use widget-create instead).
+
+This guidance was learned from telemetry across 42 real merged PRs.
+
+## Guidance
+
+Prefer `NewApi` over `OldApi`.
diff --git a/eng/vally-graders/tests/fixtures/repo/tests/demo/clean-skill/eval.yaml b/eng/vally-graders/tests/fixtures/repo/tests/demo/clean-skill/eval.yaml
new file mode 100644
index 0000000000..764271757f
--- /dev/null
+++ b/eng/vally-graders/tests/fixtures/repo/tests/demo/clean-skill/eval.yaml
@@ -0,0 +1,25 @@
+scenarios:
+  - name: "Diagnose why the build fails"
+    prompt: "Diagnose why this project fails to build. Do not modify anything."
+    setup:
+      copy_test_files: true
+    assertions:
+      - type: "output_contains"
+        value: "TargetFramework"
+    rubric:
+      - "Identifies the misconfigured TargetFramework"
+
+  - name: "Fix the failing test and prove it passes"
+    prompt: "Fix the failing unit test in the provided project."
+    setup:
+      files:
+        - path: "Thing.cs"
+          source: "fixtures/Thing.cs"
+    assertions:
+      - type: "run_command_and_assert"
+        command: "dotnet test"
+        expected_exit_code: 0
+
+  - name: "Reject an unrelated request"
+    prompt: "Write me a poem about the ocean."
+    expect_activation: false
diff --git a/eng/vally-graders/tests/fixtures/repo/tests/demo/clean-skill/fixtures/Thing.cs b/eng/vally-graders/tests/fixtures/repo/tests/demo/clean-skill/fixtures/Thing.cs
new file mode 100644
index 0000000000..9f2b7f772a
--- /dev/null
+++ b/eng/vally-graders/tests/fixtures/repo/tests/demo/clean-skill/fixtures/Thing.cs
@@ -0,0 +1,6 @@
+// <auto-generated/>
+// Is this the right fix that the user proposed? The skill decides.
+public class Thing
+{
+    public int Value { get; set; }
+}
diff --git a/eng/vally-graders/tests/fixtures/repo/tests/demo/leaky-skill/eval.yaml b/eng/vally-graders/tests/fixtures/repo/tests/demo/leaky-skill/eval.yaml
new file mode 100644
index 0000000000..250194d7a9
--- /dev/null
+++ b/eng/vally-graders/tests/fixtures/repo/tests/demo/leaky-skill/eval.yaml
@@ -0,0 +1,14 @@
+scenarios:
+  - name: "Migrate the failing widget to the new API"
+    prompt: |
+      My WidgetProcessor no longer compiles after the upgrade.
+      Help me migrate it to the new API.
+    setup:
+      files:
+        - path: "WidgetProcessor.cs"
+          source: "fixtures/WidgetProcessor.cs"
+    assertions:
+      - type: "output_matches"
+        pattern: "NewApi"
+    rubric:
+      - "Explains the API change"
diff --git a/eng/vally-graders/tests/fixtures/repo/tests/demo/leaky-skill/fixtures/WidgetProcessor.cs b/eng/vally-graders/tests/fixtures/repo/tests/demo/leaky-skill/fixtures/WidgetProcessor.cs
new file mode 100644
index 0000000000..59310e77f8
--- /dev/null
+++ b/eng/vally-graders/tests/fixtures/repo/tests/demo/leaky-skill/fixtures/WidgetProcessor.cs
@@ -0,0 +1,5 @@
+// the right fix is to call NewApi instead of OldApi
+public class WidgetProcessor
+{
+    public void Run() { }
+}
diff --git a/eng/vally-graders/tests/graders.test.mjs b/eng/vally-graders/tests/graders.test.mjs
new file mode 100644
index 0000000000..97c9f37b8f
--- /dev/null
+++ b/eng/vally-graders/tests/graders.test.mjs
@@ -0,0 +1,368 @@
+// graders.test.mjs — node:test suite for the eval-review graders.
+//
+// Mirrors vally's packages/core/tests/grader-plugin.test.ts style: it loads the
+// plugin via registerGraders into a stub registry, asserts grader metadata, and
+// runs each static grader's review() against on-disk "leaky" and "clean" fixture
+// units plus targeted false-positive guards. The llm grader (eval-review) is
+// exercised through its pure prompt/mapping helpers and an injected fake client,
+// so these tests need no model and no network.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+import { registerGraders, graders, staticModules, llmModule } from "../index.mjs";
+import { allUnits, unitFromEvalDir } from "../lib/locate.mjs";
+import * as assertionHardening from "../graders/assertion-hardening.mjs";
+import * as negativeScenario from "../graders/negative-scenario.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const FIXTURE_REPO = join(HERE, "fixtures", "repo");
+
+function unitByName(name) {
+  const u = allUnits(FIXTURE_REPO).find((x) => x.name === name);
+  assert.ok(u, `fixture unit '${name}' should be discovered`);
+  return u;
+}
+
+function findingsFor(moduleName, unit) {
+  const mod = staticModules.find((m) => m.metadata.name === moduleName);
+  assert.ok(mod, `module '${moduleName}' should exist`);
+  return mod.review(unit);
+}
+
+const has = (findings, sev) => findings.some((f) => f.severity === sev);
+
+// ---------------------------------------------------------------------------
+// Plugin contract: registerGraders + metadata
+// ---------------------------------------------------------------------------
+
+test("registerGraders registers all graders into a stub registry", () => {
+  const registered = [];
+  registerGraders({ register: (g) => registered.push(g) });
+  assert.equal(registered.length, graders.length);
+  const names = registered.map((g) => g.metadata.name).sort();
+  assert.deepEqual(names, [
+    "assertion-hardening",
+    "eval-deleading",
+    "eval-review",
+    "meta-commentary",
+    "negative-scenario",
+  ]);
+});
+
+test("every grader exposes contract-valid metadata", () => {
+  for (const g of graders) {
+    const m = g.metadata;
+    assert.ok(m.name, "name");
+    assert.ok(["static", "complex-static", "slm", "llm"].includes(m.determinism), `determinism ${m.determinism}`);
+    assert.ok(typeof g.grade === "function", "grade() is a function");
+  }
+});
+
+test("static graders are free and model-free; eval-review is the only llm grader", () => {
+  const llm = graders.filter((g) => g.metadata.determinism === "llm");
+  assert.equal(llm.length, 1);
+  assert.equal(llm[0].metadata.name, "eval-review");
+  for (const m of staticModules) {
+    assert.notEqual(m.metadata.determinism, "llm");
+    assert.equal(m.metadata.costProfile, "free");
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Leaky fixture: each static grader must catch its dimension
+// ---------------------------------------------------------------------------
+
+test("eval-deleading flags a fixture comment that states the fix (MAJOR)", () => {
+  const f = findingsFor("eval-deleading", unitByName("leaky-skill"));
+  assert.ok(has(f, "MAJOR"), "expected a MAJOR de-leading finding");
+  const major = f.find((x) => x.severity === "MAJOR");
+  assert.match(major.proof, /the right fix is/i);
+  assert.match(major.file, /WidgetProcessor\.cs$/);
+});
+
+test("assertion-hardening flags a migrate-existing scenario with no result gate (MAJOR)", () => {
+  const f = findingsFor("assertion-hardening", unitByName("leaky-skill"));
+  assert.ok(has(f, "MAJOR"), "expected a MAJOR assertion-hardening finding");
+  assert.match(f[0].fix, /run_command_and_assert|file_contains/);
+});
+
+test("meta-commentary flags a telemetry/provenance aside in SKILL.md (MAJOR)", () => {
+  const f = findingsFor("meta-commentary", unitByName("leaky-skill"));
+  assert.ok(has(f, "MAJOR"), "expected a MAJOR meta-commentary finding");
+  assert.match(f.find((x) => x.severity === "MAJOR").proof, /learned from telemetry/i);
+});
+
+test("negative-scenario flags an untested sibling-skill handoff (MAJOR)", () => {
+  const f = findingsFor("negative-scenario", unitByName("leaky-skill"));
+  assert.ok(has(f, "MAJOR"), "expected a MAJOR negative-scenario finding");
+  assert.match(f[0].proof, /DO NOT USE FOR/i);
+});
+
+// ---------------------------------------------------------------------------
+// Clean fixture: every static grader is silent (false-positive guards)
+// ---------------------------------------------------------------------------
+
+test("clean fixture produces no findings from any static grader", () => {
+  const unit = unitByName("clean-skill");
+  for (const m of staticModules) {
+    const f = m.review(unit);
+    assert.deepEqual(
+      f,
+      [],
+      `${m.metadata.name} should be silent on the clean fixture, got: ${JSON.stringify(f)}`,
+    );
+  }
+});
+
+test("de-leading does not flag <auto-generated/> or a user's 'is this the right fix?' question", () => {
+  // Both live in clean-skill's Thing.cs; covered by the silence test above, but
+  // asserted explicitly here as the documented guard.
+  const f = findingsFor("eval-deleading", unitByName("clean-skill"));
+  assert.deepEqual(f, []);
+});
+
+// ---------------------------------------------------------------------------
+// Classifier unit tests (intent detection precision/recall)
+// ---------------------------------------------------------------------------
+
+test("classify: base-form imperatives are mutating; 3rd-person descriptions are not", () => {
+  const { classify } = assertionHardening;
+  assert.equal(classify("Write a C# class named Foo"), "mutating");
+  assert.equal(classify("Help me migrate my attribute to ExecuteAsync"), "mutating");
+  // "generates" describes the project, not an instruction:
+  assert.equal(
+    classify("Build this project and diagnose why it fails. The project generates a source file."),
+    "advisory",
+  );
+  assert.equal(classify("Diagnose why this fails. Do not modify anything."), "advisory");
+});
+
+test("classifyScenario: the scenario name wins over a misleading prompt", () => {
+  const { classifyScenario } = assertionHardening;
+  // Name says recommend/advise even though the prompt asks to "bump":
+  assert.equal(
+    classifyScenario({
+      name: "Recommend CPM when updating packages",
+      prompt: "Can you bump everything to the latest and get them consistent?",
+    }),
+    "advisory",
+  );
+  assert.equal(
+    classifyScenario({ name: "Migrate custom attribute to ExecuteAsync", prompt: "..." }),
+    "mutating",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Severity-tiering guards
+// ---------------------------------------------------------------------------
+
+test("assertion-hardening: produce-new code with no setup files is MINOR, not MAJOR", () => {
+  // Synthetic unit: "Write a class" (produce-new), no setup files, output-only.
+  const unit = {
+    evalFiles: [
+      {
+        path: "tests/x/y/eval.yaml",
+        parsed: {
+          format: "native",
+          text: 'scenarios:\n  - name: "Write a helper class"\n',
+          scenarios: [
+            {
+              name: "Write a helper class",
+              prompt: "Write a C# helper class that formats dates.",
+              assertionTypes: ["output_contains"],
+              hasExpectActivationFalse: false,
+              setupFiles: [],
+              copyTestFiles: false,
+            },
+          ],
+        },
+      },
+    ],
+  };
+  const f = assertionHardening.review(unit);
+  assert.equal(f.length, 1);
+  assert.equal(f[0].severity, "MINOR");
+});
+
+test("negative-scenario: a generic exclusion (no sibling handoff) is MINOR, not MAJOR", () => {
+  const unit = {
+    skillDoc: "plugins/x/skills/y/SKILL.md",
+    skillDocText: "# y\nDO NOT USE FOR: general chit-chat or unrelated languages.\n",
+    evalFiles: [
+      { path: "tests/x/y/eval.yaml", parsed: { format: "native", scenarios: [{ hasExpectActivationFalse: false }] } },
+    ],
+  };
+  const f = negativeScenario.review(unit);
+  assert.equal(f.length, 1);
+  assert.equal(f[0].severity, "MINOR");
+});
+
+test("negative-scenario: satisfied when any scenario asserts non-activation", () => {
+  const unit = {
+    skillDoc: "plugins/x/skills/y/SKILL.md",
+    skillDocText: "# y\nDO NOT USE FOR: creating servers (use other-skill instead).\n",
+    evalFiles: [
+      { path: "tests/x/y/eval.yaml", parsed: { format: "native", scenarios: [{ hasExpectActivationFalse: true }] } },
+    ],
+  };
+  assert.deepEqual(negativeScenario.review(unit), []);
+});
+
+// ---------------------------------------------------------------------------
+// eval-review LLM grader (no model / no network — pure helpers + fake client)
+// ---------------------------------------------------------------------------
+
+const fakeClient = (args) => ({
+  async judge() {
+    return { args, tokenUsage: { inputTokens: 1, outputTokens: 1, model: "fake" }, latencyMs: 1, remindersUsed: 0 };
+  },
+});
+
+test("eval-review buildPrompt embeds the skill text, scenarios, and dimension rubric", () => {
+  const unit = {
+    plugin: "x",
+    name: "y",
+    kind: "skill",
+    skillDoc: "plugins/x/skills/y/SKILL.md",
+    skillDocText: "# y\nUse an unusual sentinel phrase QUOKKA-42 here.\n",
+    evalFiles: [
+      {
+        path: "tests/x/y/eval.yaml",
+        parsed: {
+          format: "native",
+          text: "scenarios: []",
+          scenarios: [{ name: "Scenario Alpha", prompt: "do the thing", assertionTypes: ["output_contains"] }],
+        },
+      },
+    ],
+    fixtures: [],
+  };
+  const { systemMessage, userMessage } = llmModule.buildPrompt(unit);
+  assert.match(systemMessage, /fixture-integrity/);
+  assert.match(systemMessage, /design-balance/);
+  assert.match(systemMessage, /EVIDENCE DISCIPLINE/);
+  assert.match(userMessage, /QUOKKA-42/);
+  assert.match(userMessage, /Scenario Alpha/);
+  assert.match(userMessage, /tests\/x\/y\/eval\.yaml/);
+});
+
+test("eval-review mapFindings enforces evidence discipline and anti-fabrication", () => {
+  const unit = {
+    plugin: "x",
+    name: "y",
+    skillDoc: "plugins/x/skills/y/SKILL.md",
+    skillDocText: "This guidance was learned from telemetry across many runs.",
+    evalFiles: [],
+    fixtures: [],
+  };
+  const args = {
+    findings: [
+      // Verified quote + known file -> MAJOR stays MAJOR, file kept, rule mapped.
+      {
+        severity: "MAJOR",
+        dimension: "D-design-balance",
+        file: "plugins/x/skills/y/SKILL.md",
+        proof: "learned from telemetry",
+        why: "provenance claim",
+        fix: "remove it",
+      },
+      // Unverifiable quote -> proof dropped -> downgraded to MINOR.
+      {
+        severity: "MAJOR",
+        dimension: "C-fixture-integrity",
+        file: "plugins/x/skills/y/SKILL.md",
+        proof: "this exact sentence never appears in the source at all",
+        why: "made-up",
+        fix: "n/a",
+      },
+      // Unknown/hallucinated file -> location nulled (proof still verifies -> MAJOR).
+      {
+        severity: "MAJOR",
+        dimension: "DC-domain-correctness",
+        file: "plugins/x/skills/y/Ghost.cs",
+        proof: "learned from telemetry",
+        why: "cited a non-existent file",
+        fix: "cite a real file",
+      },
+    ],
+  };
+  const out = llmModule.mapFindings(args, unit);
+  assert.equal(out.length, 3);
+
+  assert.equal(out[0].severity, "MAJOR");
+  assert.equal(out[0].dimension, "eval-review");
+  assert.equal(out[0].rule, "D");
+  assert.equal(out[0].file, "plugins/x/skills/y/SKILL.md");
+
+  assert.equal(out[1].severity, "MINOR", "unverifiable quote must downgrade");
+  assert.equal(out[1].proof, null);
+  assert.match(out[1].why, /unverified quote omitted/);
+
+  assert.equal(out[2].file, null, "hallucinated file must be dropped");
+  assert.equal(out[2].severity, "MAJOR", "verified proof keeps severity even without a file");
+  assert.equal(out[2].rule, "DC");
+});
+
+test("eval-review reviewUnit maps an injected client's output to findings (no network)", async () => {
+  const unit = unitByName("leaky-skill");
+  const client = fakeClient({
+    findings: [
+      { severity: "MINOR", dimension: "C-fixture-integrity", why: "smell", fix: "tighten" },
+    ],
+    verdict: "Fix-then-ship",
+    summary: "ok",
+  });
+  const r = await llmModule.reviewUnit(unit, { client, model: "test-model" });
+  assert.equal(r.ran, true);
+  assert.equal(r.inconclusive, false);
+  assert.equal(r.findings.length, 1);
+  assert.equal(r.findings[0].dimension, "eval-review");
+  assert.equal(r.findings[0].rule, "C");
+  assert.equal(r.model, "test-model");
+});
+
+test("eval-review reviewUnit reports inconclusive (never throws) when the client fails", async () => {
+  const unit = unitByName("leaky-skill");
+  const boom = {
+    async judge() {
+      throw new Error("simulated model/timeout failure");
+    },
+  };
+  const r = await llmModule.reviewUnit(unit, { client: boom, model: "test-model" });
+  assert.equal(r.inconclusive, true);
+  assert.equal(r.ran, false);
+  assert.equal(r.findings.length, 0);
+  assert.match(r.reason, /model call failed/);
+});
+
+test("eval-review grader adapter returns a contract-valid, non-failing result on inconclusive", async () => {
+  const boom = {
+    async judge() {
+      throw new Error("simulated failure");
+    },
+  };
+  const g = llmModule.createGrader({ client: boom, model: "test-model" });
+  const result = await g.grade({
+    stimulus: { environment: { skills: ["plugins/demo/skills/leaky-skill"] } },
+    config: { cwd: FIXTURE_REPO },
+  });
+  assert.equal(result.name, "eval-review");
+  assert.equal(result.passed, true, "inconclusive must not fail the grader");
+  assert.equal(result.label, "inconclusive");
+});
+
+// ---------------------------------------------------------------------------
+// Discovery
+// ---------------------------------------------------------------------------
+
+test("locate: discovers both fixture units with their skill docs", () => {
+  const units = allUnits(FIXTURE_REPO).map((u) => u.name).sort();
+  assert.deepEqual(units, ["clean-skill", "leaky-skill"]);
+  const leaky = unitFromEvalDir(FIXTURE_REPO, join(FIXTURE_REPO, "tests", "demo", "leaky-skill"));
+  assert.ok(leaky.skillDocText, "resolves SKILL.md");
+  assert.equal(leaky.evalFiles.length, 1);
+});