Add leaderboard auto-sync implementation plan

12 TDD tasks: pure transform lib (parse/derive/validate/diff) with unit
tests, sync.mjs orchestrator (check/apply/push), page render + fallback,
SKILL.md, daily CronCreate. Push gated behind explicit --push flag.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

docs/superpowers/plans/2026-06-02-leaderboard-sync.md

@@ -0,0 +1,1123 @@
+# Leaderboard Auto-Sync Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make the three landing-page leaderboards (EOG, EVA-Accuracy, EVA-Experience) render from a synced `data/leaderboard.json`, and add a Claude Code skill that daily pulls the two upstream sources, re-derives that JSON, and pushes to staging only when our displayed data changes and passes sanity checks.
+
+**Architecture:** Pure transform functions (no I/O) parse upstream → derive our schema; they're unit-tested with small synthetic fixtures. A `sync.mjs` orchestrator does fetch/diff/git/notify around them. The page keeps its current static markup as a fallback and an inline script overlays the fetched JSON on load. Push to staging is gated behind an explicit `--push` flag so dev runs can never deploy by accident.
+
+**Tech Stack:** Node 20 (global `fetch`, `node:test`, `node:assert`, `node:crypto`, `node:child_process`), zero npm dependencies, vanilla inline JS on the page, Tailwind-CDN markup (unchanged classes).
+
+---
+
+## File Structure
+
+**Create:**
+- `.claude/skills/sync-nowai-leaderboard/package.json` — marks ESM + `test` script.
+- `.claude/skills/sync-nowai-leaderboard/lib/transform.mjs` — pure parse/derive/validate/diff functions. No I/O.
+- `.claude/skills/sync-nowai-leaderboard/sync.mjs` — orchestrator: fetch, hash, diff, git, notify, arg parsing.
+- `.claude/skills/sync-nowai-leaderboard/SKILL.md` — when/how to run, guardrails.
+- `.claude/skills/sync-nowai-leaderboard/test/transform.test.mjs` — unit tests for transform.mjs.
+- `data/leaderboard.json` — the rendered data (generated from live upstream in Task 8).
+
+**Modify:**
+- `index.html` — add id hooks to the three cards' dynamic regions + an inline render script with fetch + fallback.
+
+**Responsibilities:** `transform.mjs` is the only place that knows upstream shapes and our schema (testable in isolation). `sync.mjs` owns side effects (network, fs, git). The page's inline script owns presentation. Split by responsibility so each unit fits in context.
+
+---
+
+### Task 1: Skill scaffolding
+
+**Files:**
+- Create: `.claude/skills/sync-nowai-leaderboard/package.json`
+
+- [ ] **Step 1: Create package.json**
+
+```json
+{
+  "name": "sync-nowai-leaderboard",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test"
+  }
+}
+```
+
+- [ ] **Step 2: Verify test runner wiring (no tests yet → exits 0 with "no test files")**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: exit 0, message like `tests 0`. (If it errors on no files, that's fine — proceed; Task 2 adds the first test.)
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add .claude/skills/sync-nowai-leaderboard/package.json
+git commit -m "chore: scaffold sync-nowai-leaderboard skill"
+```
+
+---
+
+### Task 2: EOG parser (`parseEogData`)
+
+**Files:**
+- Create: `.claude/skills/sync-nowai-leaderboard/test/transform.test.mjs`
+- Create: `.claude/skills/sync-nowai-leaderboard/lib/transform.mjs`
+
+- [ ] **Step 1: Write the failing test**
+
+Create `test/transform.test.mjs`:
+
+```js
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseEogData } from '../lib/transform.mjs';
+
+const EOG_SAMPLE = `
+// ── Leaderboard Data ──
+const LEADERBOARD_DATA = [
+  // Closed Source
+  { model: "Gemini 3.5 Flash (High)", type: "closed", teams: 48.0, csm: 47.9, email: 55.8, itsm: 42.5, calendar: 42.3, hr: 40.8, drive: 55.2, hybrid: 35.3, avg: 46.0 },
+  { model: "Claude Opus 4.5", type: "closed", teams: 50.0, csm: 34.2, email: 51.9, itsm: 23.8, calendar: 43.2, hr: 32.1, drive: 49.5, hybrid: 30.7, avg: 37.0 },
+];
+function renderLeaderboard() {}
+`;
+
+test('parseEogData extracts the array of model objects', () => {
+  const arr = parseEogData(EOG_SAMPLE);
+  assert.equal(arr.length, 2);
+  assert.equal(arr[0].model, 'Gemini 3.5 Flash (High)');
+  assert.equal(arr[0].type, 'closed');
+  assert.equal(arr[0].avg, 46.0);
+  assert.equal(arr[1].model, 'Claude Opus 4.5');
+});
+
+test('parseEogData throws when marker missing', () => {
+  assert.throws(() => parseEogData('const X = 1;'), /LEADERBOARD_DATA not found/);
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: FAIL — `Cannot find module '../lib/transform.mjs'`.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Create `lib/transform.mjs`:
+
+```js
+// Pure transforms: parse upstream sources and derive our leaderboard schema.
+// No network or filesystem access lives here.
+
+export function parseEogData(scriptText) {
+  const start = scriptText.indexOf('LEADERBOARD_DATA');
+  if (start === -1) throw new Error('LEADERBOARD_DATA not found in EOG script');
+  const open = scriptText.indexOf('[', start);
+  if (open === -1) throw new Error('EOG array open bracket not found');
+
+  // Match brackets to find the array literal end. Model names contain no [ or ].
+  let depth = 0;
+  let end = -1;
+  for (let i = open; i < scriptText.length; i++) {
+    const c = scriptText[i];
+    if (c === '[') depth++;
+    else if (c === ']') {
+      depth--;
+      if (depth === 0) { end = i; break; }
+    }
+  }
+  if (end === -1) throw new Error('EOG array close bracket not found');
+
+  let body = scriptText.slice(open, end + 1);
+  body = body.replace(/\/\/[^\n]*/g, '');              // strip line comments
+  body = body.replace(/([{,]\s*)([A-Za-z_]\w*)\s*:/g, '$1"$2":'); // quote keys
+  body = body.replace(/,(\s*[}\]])/g, '$1');           // strip trailing commas
+
+  try {
+    return JSON.parse(body);
+  } catch (e) {
+    throw new Error('EOG array parse failed: ' + e.message);
+  }
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: PASS (2/2).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add .claude/skills/sync-nowai-leaderboard/lib/transform.mjs .claude/skills/sync-nowai-leaderboard/test/transform.test.mjs
+git commit -m "feat: parse EOG LEADERBOARD_DATA array from script.js"
+```
+
+---
+
+### Task 3: EOG derivation (`deriveEog`) + vendor map (`vendorFromName`)
+
+**Files:**
+- Modify: `.claude/skills/sync-nowai-leaderboard/test/transform.test.mjs`
+- Modify: `.claude/skills/sync-nowai-leaderboard/lib/transform.mjs`
+
+- [ ] **Step 1: Add failing tests**
+
+Append to `test/transform.test.mjs`:
+
+```js
+import { deriveEog, vendorFromName } from '../lib/transform.mjs';
+
+test('vendorFromName maps known model families', () => {
+  assert.equal(vendorFromName('Gemini 3.5 Flash'), 'Google');
+  assert.equal(vendorFromName('GPT-5.4'), 'OpenAI');
+  assert.equal(vendorFromName('Claude Opus 4.5'), 'Anthropic');
+  assert.equal(vendorFromName('Mystery-7B'), 'Mystery-7B'); // fallback: first token
+});
+
+test('deriveEog sorts by avg desc, takes top 5, computes bars', () => {
+  const arr = [
+    { model: 'A', type: 'closed', avg: 20 },
+    { model: 'B', type: 'open', avg: 40 },
+    { model: 'C', type: 'closed', avg: 30 },
+  ];
+  const out = deriveEog(arr);
+  assert.equal(out.metricLabel, 'Task Success Rate · Oracle mode');
+  assert.deepEqual(out.rows.map(r => r.model), ['B', 'C', 'A']);
+  assert.equal(out.rows[0].rank, 1);
+  assert.equal(out.rows[0].score, 40);
+  assert.equal(out.rows[0].bar, 100);
+  assert.equal(out.rows[1].bar, 75);   // 30/40
+  assert.equal(out.rows[2].bar, 50);   // 20/40
+  assert.equal(out.rows[0].type, 'open');
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: FAIL — `deriveEog`/`vendorFromName` not exported.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Append to `lib/transform.mjs`:
+
+```js
+const round1 = (n) => Math.round(n * 10) / 10;
+
+const VENDOR_MAP = [
+  [/gemini/i, 'Google'],
+  [/gpt|openai|\brealtime\b/i, 'OpenAI'],
+  [/whisper/i, 'OpenAI'],
+  [/claude/i, 'Anthropic'],
+  [/nova/i, 'Amazon'],
+  [/qwen/i, 'Alibaba'],
+  [/deepseek/i, 'DeepSeek'],
+  [/llama/i, 'Meta'],
+];
+
+export function vendorFromName(name) {
+  for (const [re, vendor] of VENDOR_MAP) if (re.test(name)) return vendor;
+  return name.split(/[\s+]/)[0];
+}
+
+export function deriveEog(eogArray) {
+  const sorted = [...eogArray].sort((a, b) => b.avg - a.avg).slice(0, 5);
+  const top = sorted[0]?.avg ?? 0;
+  return {
+    metricLabel: 'Task Success Rate · Oracle mode',
+    rows: sorted.map((m, i) => ({
+      rank: i + 1,
+      model: m.model,
+      org: vendorFromName(m.model),
+      type: m.type,
+      score: round1(m.avg),
+      bar: top ? Math.round((m.avg / top) * 100) : 0,
+    })),
+  };
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: PASS (all).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add .claude/skills/sync-nowai-leaderboard/lib/transform.mjs .claude/skills/sync-nowai-leaderboard/test/transform.test.mjs
+git commit -m "feat: derive EOG top-5 rows with vendor + relative bars"
+```
+
+---
+
+### Task 4: EVA board derivation (`parseEvaData`, `deriveEvaBoard`)
+
+**Files:**
+- Modify: `.claude/skills/sync-nowai-leaderboard/test/transform.test.mjs`
+- Modify: `.claude/skills/sync-nowai-leaderboard/lib/transform.mjs`
+
+- [ ] **Step 1: Add failing tests**
+
+Append to `test/transform.test.mjs`:
+
+```js
+import { parseEvaData, deriveEvaBoard } from '../lib/transform.mjs';
+
+const EVA_SAMPLE = JSON.stringify({
+  systems: [
+    {
+      id: 'a', name: 'Gemini Live', type: 's2s', stt: '-', llm: 'gemini', tts: '-',
+      clean: {
+        'EVA-A_mean': { pooled: { point: 0.30, ci_lower: 0.28, ci_upper: 0.32 } },
+        'EVA-X_mean': { pooled: { point: 0.49, ci_lower: 0.47, ci_upper: 0.51 } },
+      },
+    },
+    {
+      id: 'b', name: 'Nova + GPT + Sonic', type: 'cascade', stt: 'Nova', llm: 'GPT', tts: 'Sonic',
+      clean: {
+        'EVA-A_mean': { pooled: { point: 0.41, ci_lower: 0.39, ci_upper: 0.43 } },
+        'EVA-X_mean': { pooled: { point: 0.20, ci_lower: 0.18, ci_upper: 0.22 } },
+      },
+    },
+  ],
+});
+
+test('parseEvaData returns parsed object with systems array', () => {
+  const data = parseEvaData(EVA_SAMPLE);
+  assert.equal(data.systems.length, 2);
+});
+
+test('deriveEvaBoard ranks by accuracy point, builds subtitle + ci + bars', () => {
+  const data = parseEvaData(EVA_SAMPLE);
+  const out = deriveEvaBoard(data.systems, 'EVA-A_mean');
+  assert.equal(out.metricLabel, 'Pass@1');
+  assert.deepEqual(out.rows.map(r => r.name), ['Nova + GPT + Sonic', 'Gemini Live']);
+  assert.equal(out.rows[0].score, 0.41);
+  assert.equal(out.rows[0].subtitle, 'Mixed Models · Cascade');
+  assert.equal(out.rows[0].bar, 100);
+  assert.equal(out.rows[0].ciLower, 0.39);
+  assert.equal(out.rows[0].ciUpper, 0.43);
+  assert.equal(out.rows[1].subtitle, 'Google · Speech-to-Speech');
+  assert.equal(out.rows[1].bar, 73); // 0.30/0.41 = 0.7317 → 73
+});
+
+test('deriveEvaBoard ranks experience board independently', () => {
+  const data = parseEvaData(EVA_SAMPLE);
+  const out = deriveEvaBoard(data.systems, 'EVA-X_mean');
+  assert.deepEqual(out.rows.map(r => r.name), ['Gemini Live', 'Nova + GPT + Sonic']);
+  assert.equal(out.rows[0].score, 0.49);
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: FAIL — `parseEvaData`/`deriveEvaBoard` not exported.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Append to `lib/transform.mjs`:
+
+```js
+const round2 = (n) => Math.round(n * 100) / 100;
+
+export function parseEvaData(jsonText) {
+  const data = JSON.parse(jsonText);
+  if (!Array.isArray(data.systems)) throw new Error('EVA data missing systems[] array');
+  return data;
+}
+
+export function deriveEvaBoard(systems, metricKey) {
+  const scored = systems
+    .map((s) => ({ s, pooled: s.clean?.[metricKey]?.pooled }))
+    .filter((x) => x.pooled && typeof x.pooled.point === 'number')
+    .sort((a, b) => b.pooled.point - a.pooled.point)
+    .slice(0, 5);
+  const top = scored[0]?.pooled.point ?? 0;
+  return {
+    metricLabel: 'Pass@1',
+    rows: scored.map(({ s, pooled }, i) => ({
+      rank: i + 1,
+      name: s.name,
+      subtitle:
+        s.type === 'cascade'
+          ? 'Mixed Models · Cascade'
+          : `${vendorFromName(s.name)} · Speech-to-Speech`,
+      score: round2(pooled.point),
+      ciLower: round2(pooled.ci_lower),
+      ciUpper: round2(pooled.ci_upper),
+      bar: top ? Math.round((pooled.point / top) * 100) : 0,
+    })),
+  };
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: PASS (all).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add .claude/skills/sync-nowai-leaderboard/lib/transform.mjs .claude/skills/sync-nowai-leaderboard/test/transform.test.mjs
+git commit -m "feat: derive EVA accuracy/experience boards from leaderboardStats.json"
+```
+
+---
+
+### Task 5: Assemble full object (`buildLeaderboard`) + change diff (`diffBoards`, `hasChanges`)
+
+**Files:**
+- Modify: `.claude/skills/sync-nowai-leaderboard/test/transform.test.mjs`
+- Modify: `.claude/skills/sync-nowai-leaderboard/lib/transform.mjs`
+
+- [ ] **Step 1: Add failing tests**
+
+Append to `test/transform.test.mjs`:
+
+```js
+import { buildLeaderboard, hasChanges, diffBoards } from '../lib/transform.mjs';
+
+test('buildLeaderboard assembles all three boards plus meta', () => {
+  const out = buildLeaderboard({
+    eogScript: EOG_SAMPLE,
+    evaJson: EVA_SAMPLE,
+    sources: { eog: { url: 'u1', hash: 'h1' }, eva: { url: 'u2', hash: 'h2' } },
+    now: '2026-06-02T00:00:00Z',
+  });
+  assert.equal(out.updated, '2026-06-02T00:00:00Z');
+  assert.equal(out.sources.eog.hash, 'h1');
+  assert.equal(out.eog.rows[0].model, 'Gemini 3.5 Flash (High)');
+  assert.equal(out.evaAccuracy.rows[0].name, 'Nova + GPT + Sonic');
+  assert.equal(out.evaExperience.rows[0].name, 'Gemini Live');
+});
+
+test('hasChanges ignores meta, detects board changes', () => {
+  const base = buildLeaderboard({ eogScript: EOG_SAMPLE, evaJson: EVA_SAMPLE, sources: {}, now: 'A' });
+  const sameDataNewMeta = buildLeaderboard({ eogScript: EOG_SAMPLE, evaJson: EVA_SAMPLE, sources: { eog: { hash: 'x' } }, now: 'B' });
+  assert.equal(hasChanges(base, sameDataNewMeta), false);
+
+  const changedEog = EOG_SAMPLE.replace('avg: 46.0', 'avg: 99.0');
+  const changed = buildLeaderboard({ eogScript: changedEog, evaJson: EVA_SAMPLE, sources: {}, now: 'A' });
+  assert.equal(hasChanges(base, changed), true);
+});
+
+test('diffBoards produces human-readable change lines', () => {
+  const base = buildLeaderboard({ eogScript: EOG_SAMPLE, evaJson: EVA_SAMPLE, sources: {}, now: 'A' });
+  const changedEog = EOG_SAMPLE.replace('avg: 46.0', 'avg: 41.0');
+  const changed = buildLeaderboard({ eogScript: changedEog, evaJson: EVA_SAMPLE, sources: {}, now: 'A' });
+  const lines = diffBoards(base, changed);
+  assert.ok(lines.some((l) => l.startsWith('eog:')));
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: FAIL — `buildLeaderboard`/`hasChanges`/`diffBoards` not exported.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Append to `lib/transform.mjs`:
+
+```js
+export function buildLeaderboard({ eogScript, evaJson, sources, now }) {
+  const eogArray = parseEogData(eogScript);
+  const evaData = parseEvaData(evaJson);
+  return {
+    updated: now,
+    sources,
+    eog: deriveEog(eogArray),
+    evaAccuracy: deriveEvaBoard(evaData.systems, 'EVA-A_mean'),
+    evaExperience: deriveEvaBoard(evaData.systems, 'EVA-X_mean'),
+  };
+}
+
+const BOARD_KEYS = ['eog', 'evaAccuracy', 'evaExperience'];
+
+// Compare only the parts we render (ignore `updated`/`sources` meta).
+export function hasChanges(oldData, newData) {
+  if (!oldData) return true;
+  const pick = (d) => JSON.stringify(BOARD_KEYS.map((k) => d[k]));
+  return pick(oldData) !== pick(newData);
+}
+
+export function diffBoards(oldData, newData) {
+  const label = (r) => r.model ?? r.name;
+  const lines = [];
+  for (const key of BOARD_KEYS) {
+    const oldRows = oldData?.[key]?.rows ?? [];
+    const newRows = newData[key].rows;
+    const oldStr = oldRows.map((r) => `${label(r)}=${r.score}`).join(', ');
+    const newStr = newRows.map((r) => `${label(r)}=${r.score}`).join(', ');
+    if (oldStr !== newStr) {
+      lines.push(`${key}:\n  old: ${oldStr || '(none)'}\n  new: ${newStr}`);
+    }
+  }
+  return lines;
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: PASS (all).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add .claude/skills/sync-nowai-leaderboard/lib/transform.mjs .claude/skills/sync-nowai-leaderboard/test/transform.test.mjs
+git commit -m "feat: assemble full leaderboard object + change detection/diff"
+```
+
+---
+
+### Task 6: Sanity gates (`validate`)
+
+**Files:**
+- Modify: `.claude/skills/sync-nowai-leaderboard/test/transform.test.mjs`
+- Modify: `.claude/skills/sync-nowai-leaderboard/lib/transform.mjs`
+
+- [ ] **Step 1: Add failing tests**
+
+Append to `test/transform.test.mjs`:
+
+```js
+import { validate } from '../lib/transform.mjs';
+
+function boardWith(rows) { return { metricLabel: 'x', rows }; }
+function dataWith(eogRows, accRows, expRows) {
+  return { eog: boardWith(eogRows), evaAccuracy: boardWith(accRows), evaExperience: boardWith(expRows) };
+}
+
+test('validate passes clean data', () => {
+  const good = dataWith(
+    [{ rank: 1, model: 'A', score: 46 }, { rank: 2, model: 'B', score: 40 }, { rank: 3, model: 'C', score: 30 }],
+    [{ rank: 1, name: 'X', score: 0.4 }, { rank: 2, name: 'Y', score: 0.3 }, { rank: 3, name: 'Z', score: 0.2 }],
+    [{ rank: 1, name: 'X', score: 0.5 }, { rank: 2, name: 'Y', score: 0.4 }, { rank: 3, name: 'Z', score: 0.3 }],
+  );
+  assert.deepEqual(validate(good, null), []);
+});
+
+test('validate flags too-few rows', () => {
+  const bad = dataWith([{ rank: 1, model: 'A', score: 46 }], [], []);
+  const issues = validate(bad, null);
+  assert.ok(issues.some((i) => i.includes('eog') && i.includes('<3')));
+});
+
+test('validate flags out-of-range scores', () => {
+  const bad = dataWith(
+    [{ rank: 1, model: 'A', score: 150 }, { rank: 2, model: 'B', score: 40 }, { rank: 3, model: 'C', score: 30 }],
+    [{ rank: 1, name: 'X', score: 0.4 }, { rank: 2, name: 'Y', score: 0.3 }, { rank: 3, name: 'Z', score: 0.2 }],
+    [{ rank: 1, name: 'X', score: 0.5 }, { rank: 2, name: 'Y', score: 0.4 }, { rank: 3, name: 'Z', score: 0.3 }],
+  );
+  assert.ok(validate(bad, null).some((i) => i.includes('out of')));
+});
+
+test('validate flags suspicious top-score swing vs previous', () => {
+  const prev = dataWith(
+    [{ rank: 1, model: 'A', score: 46 }, { rank: 2, model: 'B', score: 40 }, { rank: 3, model: 'C', score: 30 }],
+    [{ rank: 1, name: 'X', score: 0.4 }, { rank: 2, name: 'Y', score: 0.3 }, { rank: 3, name: 'Z', score: 0.2 }],
+    [{ rank: 1, name: 'X', score: 0.5 }, { rank: 2, name: 'Y', score: 0.4 }, { rank: 3, name: 'Z', score: 0.3 }],
+  );
+  const now = dataWith(
+    [{ rank: 1, model: 'A', score: 10 }, { rank: 2, model: 'B', score: 8 }, { rank: 3, model: 'C', score: 6 }],
+    [{ rank: 1, name: 'X', score: 0.4 }, { rank: 2, name: 'Y', score: 0.3 }, { rank: 3, name: 'Z', score: 0.2 }],
+    [{ rank: 1, name: 'X', score: 0.5 }, { rank: 2, name: 'Y', score: 0.4 }, { rank: 3, name: 'Z', score: 0.3 }],
+  );
+  assert.ok(validate(now, prev).some((i) => i.includes('swing')));
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: FAIL — `validate` not exported.
+
+- [ ] **Step 3: Write minimal implementation**
+
+Append to `lib/transform.mjs`:
+
+```js
+// Returns an array of human-readable issue strings; empty array = clean.
+export function validate(newData, oldData) {
+  const issues = [];
+  const specs = [
+    ['eog', newData.eog, 0, 100, 25, oldData?.eog],
+    ['evaAccuracy', newData.evaAccuracy, 0, 1, 0.25, oldData?.evaAccuracy],
+    ['evaExperience', newData.evaExperience, 0, 1, 0.25, oldData?.evaExperience],
+  ];
+  for (const [name, board, min, max, guard, oldBoard] of specs) {
+    if (!board || !Array.isArray(board.rows)) {
+      issues.push(`${name}: missing rows`);
+      continue;
+    }
+    if (board.rows.length < 3) issues.push(`${name}: only ${board.rows.length} rows (<3)`);
+    for (const r of board.rows) {
+      if (r.score < min || r.score > max) {
+        issues.push(`${name}: score ${r.score} out of [${min},${max}]`);
+      }
+    }
+    const oldTop = oldBoard?.rows?.[0]?.score;
+    const newTop = board.rows[0]?.score;
+    if (typeof oldTop === 'number' && typeof newTop === 'number') {
+      const delta = Math.abs(newTop - oldTop);
+      if (delta > guard) issues.push(`${name}: top score swing ${delta.toFixed(2)} > ${guard}`);
+    }
+  }
+  return issues;
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node --test`
+Expected: PASS (all).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add .claude/skills/sync-nowai-leaderboard/lib/transform.mjs .claude/skills/sync-nowai-leaderboard/test/transform.test.mjs
+git commit -m "feat: add sanity-gate validation for derived leaderboard"
+```
+
+---
+
+### Task 7: Orchestrator `sync.mjs` (fetch, hash, git, notify, arg parsing)
+
+**Files:**
+- Create: `.claude/skills/sync-nowai-leaderboard/sync.mjs`
+
+Modes: `--check` (diff only, no writes), `--apply` (write `data/leaderboard.json` + git commit, NO push), `--push` (implies apply + push to `origin`/staging). Default is `--check`. Push is opt-in so dev runs never deploy.
+
+- [ ] **Step 1: Create sync.mjs**
+
+```js
+#!/usr/bin/env node
+// Orchestrator for the leaderboard sync. Side effects only; pure logic in lib/transform.mjs.
+import { readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { join } from 'node:path';
+import { buildLeaderboard, hasChanges, diffBoards, validate } from './lib/transform.mjs';
+
+const EOG_URL = 'https://raw.githubusercontent.com/EnterpriseOps-Gym/EnterpriseOps-Gym.github.io/main/script.js';
+const EVA_URL = 'https://raw.githubusercontent.com/ServiceNow/eva/main/website/src/data/leaderboardStats.json';
+
+function repoRoot() {
+  return execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).trim();
+}
+
+function sha256(text) {
+  return 'sha256:' + createHash('sha256').update(text).digest('hex');
+}
+
+async function fetchText(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`fetch ${url} → HTTP ${res.status}`);
+  return res.text();
+}
+
+async function notify(message) {
+  const url = process.env.TEAMS_WEBHOOK_URL;
+  if (!url) {
+    console.log('[notify] (no TEAMS_WEBHOOK_URL set) ' + message);
+    return;
+  }
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text: message }),
+    });
+    if (!res.ok) console.error(`[notify] webhook HTTP ${res.status}`);
+  } catch (e) {
+    console.error('[notify] webhook failed: ' + e.message);
+  }
+}
+
+function git(root, args) {
+  return execFileSync('git', args, { cwd: root, encoding: 'utf8' });
+}
+
+async function main() {
+  const args = new Set(process.argv.slice(2));
+  const mode = args.has('--push') ? 'push' : args.has('--apply') ? 'apply' : 'check';
+
+  const root = repoRoot();
+  const dataPath = join(root, 'data', 'leaderboard.json');
+
+  // 1. Fetch upstream.
+  let eogScript, evaJson;
+  try {
+    [eogScript, evaJson] = await Promise.all([fetchText(EOG_URL), fetchText(EVA_URL)]);
+  } catch (e) {
+    console.error('[sync] fetch failed: ' + e.message);
+    await notify('Leaderboard sync: upstream fetch failed — ' + e.message);
+    process.exit(1);
+  }
+
+  // 2. Build new data.
+  let newData;
+  try {
+    newData = buildLeaderboard({
+      eogScript,
+      evaJson,
+      sources: {
+        eog: { url: EOG_URL, hash: sha256(eogScript), fetchedAt: new Date().toISOString() },
+        eva: { url: EVA_URL, hash: sha256(evaJson), fetchedAt: new Date().toISOString() },
+      },
+      now: new Date().toISOString(),
+    });
+  } catch (e) {
+    console.error('[sync] parse/derive failed: ' + e.message);
+    await notify('Leaderboard sync: parse failed (schema drift?) — ' + e.message);
+    process.exit(1);
+  }
+
+  // 3. Load existing.
+  const oldData = existsSync(dataPath)
+    ? JSON.parse(await readFile(dataPath, 'utf8'))
+    : null;
+
+  // 4. Change detection.
+  if (!hasChanges(oldData, newData)) {
+    console.log('[sync] no display changes. Done.');
+    return;
+  }
+  const changeLines = diffBoards(oldData, newData);
+  console.log('[sync] changes detected:\n' + changeLines.join('\n'));
+
+  // 5. Sanity gates.
+  const issues = validate(newData, oldData);
+  if (issues.length) {
+    console.error('[sync] sanity gates failed:\n - ' + issues.join('\n - '));
+    await notify('Leaderboard sync ABORTED — sanity gates failed:\n' + issues.join('\n'));
+    process.exit(2);
+  }
+
+  if (mode === 'check') {
+    console.log('[sync] --check: no writes. Re-run with --apply (commit) or --push (commit + staging).');
+    return;
+  }
+
+  // 6. Write + commit.
+  await writeFile(dataPath, JSON.stringify(newData, null, 2) + '\n');
+  git(root, ['add', dataPath]);
+  const today = new Date().toISOString().slice(0, 10);
+  const msg = `Sync leaderboard: EOG + EVA ${today}\n\n${changeLines.join('\n')}`;
+  git(root, ['commit', '-m', msg]);
+  console.log('[sync] committed.');
+
+  // 7. Push (staging only) if requested.
+  if (mode === 'push') {
+    try {
+      git(root, ['push', 'origin', 'HEAD:main']);
+      console.log('[sync] pushed to origin (staging).');
+      await notify(`Leaderboard synced to staging (${changeLines.length} board change(s)). Review + promote to prod.`);
+    } catch (e) {
+      console.error('[sync] push failed: ' + e.message);
+      await notify('Leaderboard sync: commit OK but push failed — ' + e.message);
+      process.exit(3);
+    }
+  } else {
+    console.log('[sync] --apply: committed locally, not pushed. Use --push to deploy to staging.');
+  }
+}
+
+main().catch((e) => {
+  console.error('[sync] unexpected error: ' + e.message);
+  process.exit(1);
+});
+```
+
+- [ ] **Step 2: Run check mode against live upstream (smoke test, no writes)**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node sync.mjs --check`
+Expected: prints `[sync] changes detected:` with EOG/EVA lines (since no `data/leaderboard.json` exists yet), then `--check: no writes`. Exit 0. No files changed (`git status` clean except untracked plan/docs).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add .claude/skills/sync-nowai-leaderboard/sync.mjs
+git commit -m "feat: sync orchestrator with check/apply/push modes + notify"
+```
+
+---
+
+### Task 8: Generate initial `data/leaderboard.json` from live upstream
+
+**Files:**
+- Create: `data/leaderboard.json` (generated)
+
+- [ ] **Step 1: Generate + commit locally (NO push)**
+
+Run: `cd .claude/skills/sync-nowai-leaderboard && node sync.mjs --apply`
+Expected: `changes detected` → sanity gates pass → `committed.` → `--apply: committed locally, not pushed.` Exit 0.
+
+- [ ] **Step 2: Inspect the generated file**
+
+Run: `cat data/leaderboard.json` (from repo root)
+Expected: valid JSON with `eog.rows` (5 entries, top = Gemini 3.5 Flash ~46), `evaAccuracy.rows`, `evaExperience.rows` (5 each), `sources` with sha256 hashes, `updated` timestamp.
+
+Verify ranges: EOG scores 0–100, EVA scores 0–1. If anything looks malformed, STOP — the parser needs fixing before proceeding (revisit Task 2/4).
+
+- [ ] **Step 3: (commit already made by --apply in Step 1 — verify)**
+
+Run: `git log --oneline -1`
+Expected: top commit is the `Sync leaderboard:` commit created by the script.
+
+---
+
+### Task 9: Page render — id hooks + inline fetch/fallback script
+
+**Files:**
+- Modify: `index.html`
+
+The three cards keep their current static rows as the never-empty fallback. We add `id` hooks to the dynamic regions and an inline script that overlays the fetched JSON on load.
+
+- [ ] **Step 1: Add id hooks to the EOG card**
+
+In `index.html`, the EOG top-model block currently reads:
+
+```html
+<div class="text-infinite-blue font-bold text-xl leading-tight">Claude Opus 4.5</div>
+<div class="text-on-surface-variant text-sm font-medium">Anthropic</div>
+```
+
+Replace with:
+
+```html
+<div id="eog-top-name" class="text-infinite-blue font-bold text-xl leading-tight">Claude Opus 4.5</div>
+<div id="eog-top-org" class="text-on-surface-variant text-sm font-medium">Anthropic</div>
+```
+
+The EOG score span currently reads:
+
+```html
+<span class="text-infinite-blue font-bold text-3xl tabular-nums leading-none">37.4<span class="text-on-surface-variant text-lg font-medium ml-0.5">%</span></span>
+```
+
+Replace with (add id on the outer span):
+
+```html
+<span id="eog-top-score" class="text-infinite-blue font-bold text-3xl tabular-nums leading-none">37.4<span class="text-on-surface-variant text-lg font-medium ml-0.5">%</span></span>
+```
+
+The EOG runners wrapper currently reads `<div class="space-y-4">` (the one immediately containing `<!-- Runner 2 -->`). Replace its opening tag with:
+
+```html
+<div id="eog-runners" class="space-y-4">
+```
+
+- [ ] **Step 2: Add id hooks to the EVA-Accuracy split**
+
+The accuracy top block currently reads:
+
+```html
+<div class="text-infinite-blue font-bold text-base leading-tight">Nova + GPT-5.4 + Sonic</div>
+<div class="text-on-surface-variant text-[11px] font-medium">Mixed Models · Cascade</div>
+```
+
+Replace with:
+
+```html
+<div id="eva-acc-name" class="text-infinite-blue font-bold text-base leading-tight">Nova + GPT-5.4 + Sonic</div>
+<div id="eva-acc-sub" class="text-on-surface-variant text-[11px] font-medium">Mixed Models · Cascade</div>
+```
+
+The accuracy top score currently reads:
+
+```html
+<span class="text-infinite-blue font-bold text-2xl tabular-nums">0.41</span>
+```
+
+Replace with:
+
+```html
+<span id="eva-acc-score" class="text-infinite-blue font-bold text-2xl tabular-nums">0.41</span>
+```
+
+The accuracy runners wrapper currently reads `<div class="space-y-2.5">` (the one whose first child row contains `Claude Opus 4.5` at `0.32`). Replace its opening tag with:
+
+```html
+<div id="eva-acc-runners" class="space-y-2.5">
+```
+
+- [ ] **Step 3: Add id hooks to the EVA-Experience split**
+
+The experience top block currently reads:
+
+```html
+<div class="text-infinite-blue font-bold text-base leading-tight">Gemini Live</div>
+<div class="text-on-surface-variant text-[11px] font-medium">Google · Speech-to-Speech</div>
+```
+
+Replace with:
+
+```html
+<div id="eva-exp-name" class="text-infinite-blue font-bold text-base leading-tight">Gemini Live</div>
+<div id="eva-exp-sub" class="text-on-surface-variant text-[11px] font-medium">Google · Speech-to-Speech</div>
+```
+
+The experience top score currently reads:
+
+```html
+<span class="text-infinite-blue font-bold text-2xl tabular-nums">0.49</span>
+```
+
+Replace with:
+
+```html
+<span id="eva-exp-score" class="text-infinite-blue font-bold text-2xl tabular-nums">0.49</span>
+```
+
+The experience runners wrapper currently reads `<div class="space-y-2.5">` (the one whose first child row contains `GPT-Realtime` at `0.47`). Replace its opening tag with:
+
+```html
+<div id="eva-exp-runners" class="space-y-2.5">
+```
+
+- [ ] **Step 4: Add the inline render script before `</body>`**
+
+Find the closing `</body>` tag in `index.html` and insert this block immediately before it:
+
+```html
+<script>
+// Overlay synced leaderboard data on the static fallback markup.
+// On any failure, the static markup already in the DOM remains.
+(function () {
+  function esc(s) {
+    return String(s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+  }
+
+  function eogRunnerRow(r) {
+    return `<div class="grid grid-cols-[20px_1fr_100px_45px] items-center gap-3">
+<span class="text-on-surface-variant text-xs tabular-nums font-medium">${r.rank}</span>
+<span class="text-on-surface text-sm font-medium">${esc(r.model)}</span>
+<div class="h-1.5 w-full bg-infinite-soft rounded-full overflow-hidden">
+<div class="h-full fill-infinite rounded-full" style="width: ${r.bar}%;"></div>
+</div>
+<span class="text-infinite-blue text-sm font-bold text-right tabular-nums">${r.score.toFixed(1)}</span>
+</div>`;
+  }
+
+  function evaRunnerRow(r, fill) {
+    return `<div class="grid grid-cols-[18px_1fr_80px_35px] items-center gap-2 text-xs">
+<span class="text-on-surface-variant tabular-nums font-medium">${r.rank}</span>
+<span class="text-on-surface font-medium truncate">${esc(r.name)}</span>
+<div class="h-1 w-full bg-${fill}-soft rounded-full overflow-hidden">
+<div class="h-full fill-${fill} rounded-full" style="width: ${r.bar}%;"></div>
+</div>
+<span class="text-infinite-blue font-bold text-right tabular-nums">${r.score.toFixed(2)}</span>
+</div>`;
+  }
+
+  function setText(id, value) {
+    const el = document.getElementById(id);
+    if (el) el.textContent = value;
+  }
+
+  function renderEog(board) {
+    const top = board.rows[0];
+    if (!top) return;
+    setText('eog-top-name', top.model);
+    setText('eog-top-org', top.org);
+    const score = document.getElementById('eog-top-score');
+    if (score) score.innerHTML = `${top.score.toFixed(1)}<span class="text-on-surface-variant text-lg font-medium ml-0.5">%</span>`;
+    const runners = document.getElementById('eog-runners');
+    if (runners) runners.innerHTML = board.rows.slice(1).map(eogRunnerRow).join('');
+  }
+
+  function renderEvaSplit(board, prefix, fill) {
+    const top = board.rows[0];
+    if (!top) return;
+    setText(`${prefix}-name`, top.name);
+    setText(`${prefix}-sub`, top.subtitle);
+    setText(`${prefix}-score`, top.score.toFixed(2));
+    const runners = document.getElementById(`${prefix}-runners`);
+    if (runners) runners.innerHTML = board.rows.slice(1).map((r) => evaRunnerRow(r, fill)).join('');
+  }
+
+  fetch('./data/leaderboard.json', { cache: 'no-cache' })
+    .then((res) => { if (!res.ok) throw new Error('HTTP ' + res.status); return res.json(); })
+    .then((data) => {
+      if (data.eog) renderEog(data.eog);
+      if (data.evaAccuracy) renderEvaSplit(data.evaAccuracy, 'eva-acc', 'indigo');
+      if (data.evaExperience) renderEvaSplit(data.evaExperience, 'eva-exp', 'blue');
+    })
+    .catch((err) => {
+      console.warn('Leaderboard JSON load failed; showing static fallback.', err);
+    });
+})();
+</script>
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add index.html
+git commit -m "feat: render leaderboards from data/leaderboard.json with static fallback"
+```
+
+---
+
+### Task 10: Verify render in browser
+
+**Files:** none (verification only)
+
+- [ ] **Step 1: Serve the site locally**
+
+The user runs a local web server (IntelliJ) at the project root. Confirm the page is reachable (e.g. `http://localhost:63342/NowAI-Bench/index.html` or the user's configured URL). If not running, start one: `cd <repo root> && python3 -m http.server 8080` and use `http://localhost:8080/`.
+
+- [ ] **Step 2: Load the page and assert via Chrome DevTools MCP**
+
+Navigate to the page. Using `mcp__plugin_chrome-devtools-mcp_chrome-devtools__evaluate_script`, run:
+
+```js
+() => ({
+  eogRunners: document.querySelectorAll('#eog-runners > div').length,
+  accRunners: document.querySelectorAll('#eva-acc-runners > div').length,
+  expRunners: document.querySelectorAll('#eva-exp-runners > div').length,
+  eogTop: document.getElementById('eog-top-name').textContent,
+  accTop: document.getElementById('eva-acc-name').textContent,
+  expTop: document.getElementById('eva-exp-name').textContent,
+})
+```
+
+Expected: each `*Runners` count is `4` (ranks 2–5; top is rendered separately), totaling 5 per board. `eogTop` reflects the synced #1 (e.g. "Gemini 3.5 Flash (High)"), not the old static "Claude Opus 4.5".
+
+- [ ] **Step 3: Check console for errors**
+
+Use `mcp__plugin_chrome-devtools-mcp_chrome-devtools__list_console_messages`.
+Expected: no errors. (A "JSON load failed" warning means the server isn't serving `data/leaderboard.json` at the expected relative path — fix the path/serving before continuing.)
+
+- [ ] **Step 4: Screenshot for visual confirmation**
+
+Use `mcp__plugin_chrome-devtools-mcp_chrome-devtools__take_screenshot` and confirm the three cards show 5 rows each with bars, matching the prior styling.
+
+---
+
+### Task 11: Write `SKILL.md`
+
+**Files:**
+- Create: `.claude/skills/sync-nowai-leaderboard/SKILL.md`
+
+- [ ] **Step 1: Create SKILL.md**
+
+```markdown
+---
+name: sync-nowai-leaderboard
+description: Use when syncing the NowAI-Bench landing-page leaderboards from upstream EOG + EVA sources, or when a scheduled run fires to check for new results. Pulls both sources, re-derives data/leaderboard.json, and pushes to staging only on sane changes.
+---
+
+# Sync NowAI-Bench Leaderboard
+
+Pulls the two upstream leaderboard sources, re-derives `data/leaderboard.json`,
+and (when run with `--push`) deploys the change to the **staging** HF Space only.
+
+## Sources
+- EOG: `https://raw.githubusercontent.com/EnterpriseOps-Gym/EnterpriseOps-Gym.github.io/main/script.js` (`LEADERBOARD_DATA` array)
+- EVA: `https://raw.githubusercontent.com/ServiceNow/eva/main/website/src/data/leaderboardStats.json` (`systems[]`)
+
+## How to run
+
+From the repo root:
+
+1. **Preview (always do this first):**
+   `node .claude/skills/sync-nowai-leaderboard/sync.mjs --check`
+   Prints the diff vs the committed `data/leaderboard.json`. No writes.
+
+2. **Inspect the printed diff.** If it looks sane (no garbled names, scores in
+   range, no wild swings), proceed. If sanity gates already flagged issues, the
+   script aborts — investigate upstream before forcing anything.
+
+3. **Apply + deploy to staging:**
+   `node .claude/skills/sync-nowai-leaderboard/sync.mjs --push`
+   Writes the file, commits, and pushes to `origin` (staging). Notifies via
+   Teams webhook if `TEAMS_WEBHOOK_URL` is set.
+
+   To commit locally without deploying, use `--apply` instead of `--push`.
+
+## Guardrails (NON-NEGOTIABLE)
+- **Push to `origin` (staging) ONLY. NEVER push to `prod`.** Promotion to prod is
+  a human decision made after reviewing staging.
+- The script exits non-zero and notifies (does not commit) if: a fetch fails, a
+  source fails to parse, any board has <3 rows, any score is out of range
+  (EOG 0–100, EVA 0–1), or the top score swings >25 (EOG) / >0.25 (EVA) vs the
+  committed data. Do not override these by editing the JSON by hand to bypass.
+
+## Tests
+`cd .claude/skills/sync-nowai-leaderboard && node --test`
+
+## Open TBD
+- Teams webhook URL not yet provisioned. Until then, notifications print to the
+  run log. Set `TEAMS_WEBHOOK_URL` (as a secret/env var, never committed) to enable.
+```
+
+- [ ] **Step 2: Verify the skill is discoverable**
+
+Run: `git check-ignore .claude/skills/sync-nowai-leaderboard/SKILL.md`
+Expected: **no output** (file is NOT ignored — the `!.claude/skills/` rule keeps it tracked). If it prints the path, the `.gitignore` negation is wrong — fix before committing.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add .claude/skills/sync-nowai-leaderboard/SKILL.md
+git commit -m "docs: add SKILL.md for sync-nowai-leaderboard"
+```
+
+---
+
+### Task 12: Schedule the daily run
+
+**Files:** none (creates a user-level Claude Code cron, not a repo file)
+
+- [ ] **Step 1: Create the daily schedule**
+
+Use the `CronCreate` tool (load its schema via ToolSearch: `select:CronCreate`). Create a daily job whose prompt instructs Claude to run the skill end-to-end:
+
+- Schedule: daily (e.g. `0 14 * * *` — 14:00 UTC ≈ 7am PT; adjust to preference).
+- Prompt (verbatim intent): "Invoke the sync-nowai-leaderboard skill in the NowAI-Bench repo. Run `node .claude/skills/sync-nowai-leaderboard/sync.mjs --check` first; if it reports sane changes and no gate failures, run it again with `--push` to deploy to staging. Report the diff summary. Never touch prod."
+
+- [ ] **Step 2: Confirm it registered**
+
+Use the `CronList` tool (`select:CronList`). Expected: the new daily job appears.
+
+Note: the schedule lives in user-level Claude Code config, not the repo. It must be re-created on any machine that should run the sync.
+
+---
+
+## Self-Review
+
+**Spec coverage:**
+- Page refactor to `data.json` + inline render + fallback → Tasks 8, 9, 10. ✓
+- Sync skill in `.claude/skills/` → Tasks 1, 7, 11. ✓
+- Transform/mapping rules (EOG avg sort, EVA A/X boards, subtitles, vendor map, bars, CI) → Tasks 2–5. ✓
+- Compare-derived-output change detection → Task 5 (`hasChanges`). ✓
+- Sanity gates (HTTP, ≥3 rows, range, Δ guard) → Task 6 + wired in Task 7. ✓
+- Staging-only push, never prod → Task 7 (`--push` → `origin` only), Task 11 guardrails. ✓
+- Provenance hashes in `sources` → Task 7 (`sha256`). ✓
+- Teams webhook notify (TBD) + fallback → Task 7 `notify()`, Task 11 Open TBD. ✓
+- Daily cadence via CronCreate → Task 12. ✓
+- `.claude/skills/` tracked, rest ignored → verified in Task 11 Step 2. ✓
+- Tests (transform unit + render check) → Tasks 2–6 (unit), Task 10 (render). ✓
+
+**Refinement noted vs spec:** spec described `--apply` as write+commit+push. Plan splits this: `--apply` = write+commit (no push), `--push` = write+commit+push to staging. Push becomes explicit opt-in so dev/init runs (Task 8) cannot accidentally deploy. Safer; same end behavior for the cron (`--push`).
+
+**Placeholder scan:** no TBD/TODO in code steps; the only "TBD" is the Teams webhook, which is a real external dependency documented as such. ✓
+
+**Type consistency:** `parseEogData`/`deriveEog`/`parseEvaData`/`deriveEvaBoard`/`buildLeaderboard`/`hasChanges`/`diffBoards`/`validate`/`vendorFromName` names match across lib, tests, and `sync.mjs` imports. EOG rows expose `{rank,model,org,type,score,bar}`; EVA rows expose `{rank,name,subtitle,score,ciLower,ciUpper,bar}` — consistent between derive functions, the render script, and `diffBoards` (`label = r.model ?? r.name`). ✓
+
+---
+
+## Out of Scope (per spec)
+- Auto-promotion to prod.
+- Per-domain / radar view (v1.1).
+- Historical trend tracking.