refactor(mcp): rename tools to user-oriented names; remove scorer identity

MCP tool rename (validate_* is implementation-oriented, not user-oriented):
  validate_corpus_record    -> check_case
  validate_prompt_jsonl     -> check_prompt
  generate_prompt_template  -> new_prompt
  create_contribution_bundle -> bundle_prompts

Consistent verb/object structure, low cognitive load, better autocomplete,
easier to demo. Updated server.py, corpus_tools.py, prompt_tools.py,
dali_mcp/README.md, and CONTRIBUTING.md references.

Scorer identity removed:
  scoring/support.py: SCORER_MODEL hardcoded constant removed. Scorer
  is now read from DALI_SCORER_MODEL env var at runtime with a clear
  error if unset. No specific vendor is named or defaulted.
  METHODOLOGY.md: Step 4 and Scorer Bias Disclosure rewritten to be
  provider-neutral. Cross-vendor requirement stated as policy; specific
  scorer identity lives in run artifacts only.

Em dashes removed from all newly written dali_mcp content.

Author: Yen Kha

CONTRIBUTING.md

@@ -81,7 +81,7 @@ Validate your record before submitting:
 python -m corpus.validator data/public/citation_failure_cases.json
 ```
 
-Optional: the `dali_mcp/` contributor interface exposes the same validation as an MCP tool (`validate_corpus_record`) for editor-integrated workflows.
+Optional: the `dali_mcp/` contributor interface exposes the same validation as an MCP tool (`check_case`) for editor-integrated workflows.
 
 Records with `needs_verification: true` load for inspection but are excluded
 from scoring aggregates.
@@ -111,7 +111,7 @@ synthetic/
 Each record requires `id` (lowercase alphanumeric + underscore), `category`,
 `subcategory`, `prompt` (≥ 30 chars), and `difficulty`.
 
-**Easiest path:** use the `generate_prompt_template` and `create_contribution_bundle`
+**Easiest path:** use the `new_prompt` and `bundle_prompts`
 MCP tools to scaffold, validate, and package prompts. See
 [dali_mcp/README.md](dali_mcp/README.md) for setup.
 

METHODOLOGY.md

@@ -178,7 +178,7 @@ The longer-term mitigation for 403 blocking is content-addressable archival (Way
 
 ## Step 4: Support Scoring
 
-**Model:** `claude-3-5-haiku-20241022` (Anthropic) — cross-vendor scorer for all OpenAI subject models; no self-evaluation bias for GPT-4o/GPT-4.1/GPT-4o-mini results
+**Model:** LLM-based verification scorer, configurable via `DALI_SCORER_MODEL`. Use a cross-vendor model (different provider than your subject models) to avoid self-evaluation bias. The scorer model used in each run is recorded in `methodology.json`.
 **Parameters:** `temperature=0.0`, `max_tokens=256`
 **Source input:** first 3,000 characters of the fetched source text
 
@@ -252,7 +252,7 @@ If a provider deprecates a model version, a new versioned results directory is c
 
 ## Scorer Bias Disclosure
 
-The support scorer for v0.2 is `claude-3-5-haiku-20241022` (Anthropic). All v0.2 subject models are OpenAI (GPT-4o-mini, GPT-4.1, GPT-4o), so there is no self-evaluation bias in this run. The scorer model is recorded in `methodology.json` per run. If an Anthropic model is used as a subject in a future run, the scorer must be switched to a different provider.
+The scorer model is recorded in `methodology.json` per run. For any published run, the scorer must be from a different provider than the subject models being evaluated. This cross-vendor requirement is the primary guard against self-evaluation bias. The v0.2 public run satisfies this requirement; the specific scorer identity is recorded in the run artifacts rather than in this document to keep the methodology provider-neutral.
 
 ---
 

dali_mcp/README.md

@@ -1,19 +1,21 @@
-# Dali MCP — Contributor Tools
+# Dali MCP Contributor Tools
 
 Dali exposes four MCP tools so you can validate, scaffold, and bundle
 corpus records and synthetic prompts directly from Claude or any
-MCP-capable editor — without running terminal commands.
+MCP-capable editor, without running terminal commands.
 
 ## Tools
 
-| Tool | What it does |
+| Tool | Purpose |
 |---|---|
-| `validate_corpus_record` | Validates a CitationFailureCase JSON object — checks required fields, taxonomy values, lineage rules, and scoring eligibility |
-| `validate_prompt_jsonl` | Validates a single synthetic prompt JSONL entry — checks required fields, category/subcategory/difficulty taxonomy, and prompt length |
-| `generate_prompt_template` | Scaffolds a new prompt template for a given category, subcategory, and difficulty — ready to fill in and paste |
-| `create_contribution_bundle` | Validates a batch of prompts and returns a PR-ready checklist |
+| `check_case` | Validate a canonical citation-failure case |
+| `check_prompt` | Validate a synthetic benchmark prompt |
+| `new_prompt` | Generate a prompt scaffold |
+| `bundle_prompts` | Create a PR-ready contribution bundle |
 
-These tools wrap the same validation logic used by the CLI (`corpus/validator.py`, `runners/`) so there are no discrepancies between editor and terminal validation.
+These tools wrap the same validation logic used by the CLI
+(`corpus/validator.py`, `runners/`) so there are no discrepancies
+between editor and terminal validation.
 
 ---
 
@@ -25,7 +27,9 @@ These tools wrap the same validation logic used by the CLI (`corpus/validator.py
 pip install mcp
 ```
 
-The `mcp` package is listed under `# MCP server` in `requirements.txt`. The rest of Dali (Tier 1 evaluator) runs on stdlib only — `mcp` is only required if you want the editor integration.
+The `mcp` package is listed under the MCP server section in
+`requirements.txt`. The rest of Dali (Tier 1 evaluator) runs on
+stdlib only. `mcp` is only required for the editor integration.
 
 ### Claude Desktop
 
@@ -43,9 +47,9 @@ Add to your Claude Desktop `claude_desktop_config.json`:
 }
 ```
 
-Replace `/path/to/your/Dali/clone` with the absolute path to your local repo.
-
-Restart Claude Desktop. The four tools will appear in Claude's tool list.
+Replace `/path/to/your/Dali/clone` with the absolute path to your
+local repo. Restart Claude Desktop. The four tools will appear in
+the tool list.
 
 ### VS Code (with MCP extension)
 
@@ -86,37 +90,38 @@ Add to your Cursor MCP settings:
 
 ### Validate a corpus record
 
-Ask Claude:
-> "Use validate_corpus_record to check this record: `{ "case_id": "my-case-2024", "year": 2024, ... }`"
+Ask your editor assistant:
+> "Use check_case to validate this record: { "case_id": "my-case-2024", "year": 2024, ... }"
 
-The tool returns a report with `valid`, `scoring_eligible`, `issues`, and a one-line `summary`.
+The tool returns `valid`, `scoring_eligible`, `issues`, and a one-line `summary`.
 
 ### Scaffold a new adversarial prompt
 
-Ask Claude:
-> "Use generate_prompt_template for category=adversarial, subcategory=hallucination_prone, difficulty=adversarial, notes=Tests fabrication under recent AI regulation prompts"
+Ask your editor assistant:
+> "Use new_prompt for category=adversarial, subcategory=hallucination_prone, difficulty=adversarial, notes=Tests fabrication under recent AI regulation prompts"
 
-The tool returns a ready-to-fill JSONL entry and tells you which file to add it to.
+The tool returns a ready-to-fill entry and tells you which file to add it to.
 
 ### Bundle prompts for a PR
 
-Ask Claude:
-> "Use create_contribution_bundle on this list of prompts: [...]"
+Ask your editor assistant:
+> "Use bundle_prompts on this list: [...]"
 
-Returns pass/fail by prompt ID and a PR checklist.
+Returns pass/fail by prompt ID and a pre-PR checklist.
 
 ---
 
 ## CLI equivalent
 
-All tools have direct CLI equivalents if you prefer the terminal:
+All tools have direct CLI equivalents for terminal users:
 
 ```bash
 # Validate corpus
 python -m corpus.validator data/public/citation_failure_cases.json
 
-# Validate synthetic prompts (schema validation via CI)
-python -m pytest tests/ -q
+# Validate synthetic prompts (via CI schema check)
+pytest tests/ -q
 ```
 
-The MCP server is an editor-friendly wrapper — not a separate code path.
+The MCP server is an editor-friendly wrapper around the same logic,
+not a separate code path.

dali_mcp/__init__.py

@@ -2,7 +2,7 @@
 
 Exposes four tools via the Model Context Protocol so contributors can
 validate, scaffold, and bundle corpus records and synthetic prompts
-directly from Claude or any MCP-capable editor — without running
+directly from Claude or any MCP-capable editor, without running
 terminal commands.
 
 Usage:

dali_mcp/server.py

@@ -1,17 +1,17 @@
 #!/usr/bin/env python3
-"""Dali MCP server — contributor tools over the Model Context Protocol.
+"""Dali MCP server: contributor tools over the Model Context Protocol.
 
 Start the server:
     python -m dali_mcp
 
 Or via uvx (no install required):
     uvx --from . dali-mcp
 
-Tools exposed:
-    validate_corpus_record    — validate a CitationFailureCase JSON object
-    validate_prompt_jsonl     — validate a synthetic prompt JSONL entry
-    generate_prompt_template  — scaffold a new synthetic prompt
-    create_contribution_bundle — validate + summarise a batch for PR submission
+Tools:
+    check_case      Validate a canonical citation-failure case record
+    check_prompt    Validate a synthetic benchmark prompt entry
+    new_prompt      Generate a scaffolded prompt template
+    bundle_prompts  Validate a batch and return a PR-ready checklist
 """
 
 from __future__ import annotations
@@ -20,18 +20,15 @@
 import sys
 from pathlib import Path
 
-# Allow running from repo root without installing the package.
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
 from mcp.server.fastmcp import FastMCP
 
-from dali_mcp.tools.corpus_tools import (
-    _validate_corpus_record_impl,
-)
+from dali_mcp.tools.corpus_tools import _check_case_impl
 from dali_mcp.tools.prompt_tools import (
-    _create_contribution_bundle_impl,
-    _generate_prompt_template_impl,
-    _validate_prompt_jsonl_impl,
+    _bundle_prompts_impl,
+    _check_prompt_impl,
+    _new_prompt_impl,
 )
 
 mcp = FastMCP(
@@ -40,67 +37,67 @@
         "You are a Dali contributor assistant. Use these tools to validate "
         "corpus records and synthetic prompts, scaffold new entries, and "
         "bundle contributions for pull-request submission. "
-        "Always run validate_corpus_record or validate_prompt_jsonl before "
-        "creating a bundle."
+        "Run check_case or check_prompt before calling bundle_prompts."
     ),
 )
 
 
 @mcp.tool()
-def validate_corpus_record(record_json: str) -> str:
-    """Validate a CitationFailureCase corpus record.
+def check_case(record_json: str) -> str:
+    """Validate a canonical citation-failure case for the Tier 1 corpus.
 
-    Accepts a JSON object (as a string) representing one record from
+    Accepts a JSON object representing one record from
     data/public/citation_failure_cases.json. Returns a validation report
-    indicating whether the record is scoring-eligible, what required fields
+    showing whether the record is scoring-eligible, which required fields
     are missing, and any taxonomy or lineage violations.
 
     Args:
         record_json: JSON string of a single CitationFailureCase record.
             Must include at minimum: case_id, incident_name, year, jurisdiction.
 
     Returns:
-        A JSON string with keys:
-            valid (bool) — passes all scoring gates
-            scoring_eligible (bool) — can count toward published metrics
-            issues (list[str]) — list of validation failures, empty if valid
-            summary (str) — human-readable one-line status
+        JSON string with keys:
+            valid (bool) - passes all scoring gates
+            scoring_eligible (bool) - can count toward published metrics
+            issues (list[str]) - validation failures, empty if valid
+            summary (str) - one-line status
     """
-    return json.dumps(_validate_corpus_record_impl(record_json), indent=2)
+    return json.dumps(_check_case_impl(record_json), indent=2)
 
 
 @mcp.tool()
-def validate_prompt_jsonl(prompt_json: str) -> str:
-    """Validate a synthetic prompt JSONL entry for the Tier 2 corpus.
+def check_prompt(prompt_json: str) -> str:
+    """Validate a synthetic prompt entry for the Tier 2 corpus.
 
-    Accepts a single JSONL record (as a JSON string). Checks required fields,
-    taxonomy values, and prompt quality rules.
+    Accepts a single prompt record as a JSON string. Checks required
+    fields, taxonomy values, and prompt quality rules.
 
     Args:
         prompt_json: JSON string of one synthetic prompt record.
             Required fields: id, category, subcategory, prompt, difficulty.
 
     Returns:
-        A JSON string with keys:
+        JSON string with keys:
             valid (bool)
             issues (list[str])
             summary (str)
+            destination_file (str) - which synthetic/ file to add this to
     """
-    return json.dumps(_validate_prompt_jsonl_impl(prompt_json), indent=2)
+    return json.dumps(_check_prompt_impl(prompt_json), indent=2)
 
 
 @mcp.tool()
-def generate_prompt_template(
+def new_prompt(
     category: str,
     subcategory: str,
     difficulty: str,
     notes: str = "",
 ) -> str:
     """Generate a scaffolded synthetic prompt template.
 
-    Returns a ready-to-fill JSONL record with the correct field structure
-    for the given category, subcategory, and difficulty. Includes a unique
-    ID stub based on the subcategory and valid taxonomy values.
+    Returns a ready-to-fill record with the correct field structure
+    for the given category, subcategory, and difficulty level. Includes
+    a unique ID stub and tells you which file to add it to.
 
     Args:
         category: One of: legal, research, adversarial
@@ -109,38 +106,37 @@ def generate_prompt_template(
             policy_citations, hallucination_prone
         difficulty: One of: known_case, obscure_case, fabricated_likely,
             ambiguous, adversarial, standard
-        notes: Optional guidance note for what the prompt should test.
-            Appears in the 'notes' field of the template.
+        notes: Optional note describing what failure mode the prompt tests.
 
     Returns:
-        A JSONL-formatted JSON string ready to paste into the appropriate
-        synthetic/ file. The 'prompt' field contains a placeholder to replace.
+        A comment header with the destination file followed by a JSON
+        record ready to paste. Replace the placeholder prompt text before
+        submitting.
     """
-    return _generate_prompt_template_impl(category, subcategory, difficulty, notes)
+    return _new_prompt_impl(category, subcategory, difficulty, notes)
 
 
 @mcp.tool()
-def create_contribution_bundle(prompts_json: str) -> str:
-    """Validate and summarise a batch of synthetic prompts for PR submission.
+def bundle_prompts(prompts_json: str) -> str:
+    """Validate a batch of synthetic prompts and return a PR-ready checklist.
 
-    Accepts a JSON array of prompt records (each matching the synthetic
-    prompt schema). Validates every record, summarises pass/fail counts
-    by subcategory, and returns a checklist of issues to fix before
-    opening a pull request.
+    Accepts a JSON array of prompt records. Validates every record,
+    summarises pass/fail counts, and returns a checklist of issues to
+    fix before opening a pull request.
 
     Args:
         prompts_json: JSON array string of synthetic prompt records.
 
     Returns:
-        A JSON string with keys:
-            total (int) — total records in the batch
-            valid (int) — records that pass all checks
-            invalid (int) — records with issues
-            issues_by_id (dict) — {id: [issues]} for each failing record
-            pr_checklist (list[str]) — pre-PR checklist items
-            ready_to_submit (bool) — True if all records are valid
+        JSON string with keys:
+            total (int) - records in the batch
+            valid (int) - records passing all checks
+            invalid (int) - records with issues
+            issues_by_id (dict) - {id: [issues]} for each failing record
+            pr_checklist (list[str]) - pre-PR checklist items
+            ready_to_submit (bool) - True when all records are valid
     """
-    return json.dumps(_create_contribution_bundle_impl(prompts_json), indent=2)
+    return json.dumps(_bundle_prompts_impl(prompts_json), indent=2)
 
 
 def main() -> None:

dali_mcp/tools/corpus_tools.py

@@ -58,7 +58,7 @@
 }
 
 
-def _validate_corpus_record_impl(record_json: str) -> dict:
+def _check_case_impl(record_json: str) -> dict:
     issues: list[str] = []
 
     try:
@@ -68,7 +68,7 @@ def _validate_corpus_record_impl(record_json: str) -> dict:
             "valid": False,
             "scoring_eligible": False,
             "issues": [f"Invalid JSON: {e}"],
-            "summary": "Parse error — record is not valid JSON.",
+            "summary": "Parse error: record is not valid JSON.",
         }
 
     if not isinstance(record, dict):