raven-mcp 1.12.0 → 1.13.0

package/README.md

@@ -11,7 +11,7 @@ A design knowledge MCP server that Claude can query when generating UI. Eight la
 Raven gives Claude access to a comprehensive design knowledge base:
 
 - **Principles** — Nielsen's 10 Heuristics, all 21 Laws of UX, Gestalt principles, WCAG accessibility, typography rules, color theory, mobile UX, D4D framework, UX writing, service design, brand, color-systems (palette-size discipline), and spacing-systems (base-unit grid + scale limits)
-- **Patterns** — Proven UI patterns for signup flows, pricing pages, navigation, forms, landing pages, dashboards, modals, empty/error/loading states, CTAs, social proof, mobile conversion — plus content patterns (error messages, empty-state copy, notifications, form validation) and service patterns (service blueprinting, human handoff, signup-as-service, omnichannel continuity, moments of truth)
+- **Patterns** — Proven UI patterns for signup flows, pricing pages, navigation, dropdown/select menus, forms, landing pages, dashboards, modals, empty/error/loading states, CTAs, social proof, mobile conversion — plus content patterns (error messages, empty-state copy, notifications, form validation) and service patterns (service blueprinting, human handoff, signup-as-service, omnichannel continuity, moments of truth)
 - **Content systems** — Voice & tone guides from publicly documented brand systems: Mailchimp, GOV.UK, Shopify Polaris, and Atlassian
 - **Research** — Qualitative, quantitative, and usability methods with do/don't protocols and checklists. Metrics frameworks: HEART, AARRR/Pirate, North Star Metric, conversion funnel, RICE, OKRs.
 - **Service design** — Service blueprinting (with HTML blueprint generation — current vs. ideal state), human-handoff patterns, signup-as-service, omnichannel continuity, moments of truth / recovery, and the GOV.UK Service Standard
@@ -63,8 +63,9 @@ cd raven-mcp && npm install && npm run build
 | `get_design_system` | Get tokens for a specific design system |
 | `compose_system` | Mix tokens from different systems |
 | `get_brand_system` | Get a full system styled like a well-known brand |
-| `audit_page` | Audit HTML/CSS against Raven's quality standards — pass `html` for static audit, or `url` to render headless with optional `scroll_settle` (scroll to bottom + settle reveals) and `viewport` parameters; `containerMaxWidth` makes container checks token-aware. Pass `compact: true` to return only scores, violations, and fix_priority (drops embedded base64 screenshots) when the full payload is too large. |
-| `audit_layout` | Evaluate visual rhythm, alignment, and optical balance |
+| `audit_page` | Audit HTML/CSS against Raven's quality standards — pass `html` for static audit, or `url` to render headless with optional `scroll_settle` (scroll to bottom + settle reveals) and `viewport` parameters; `containerMaxWidth` makes container checks token-aware. Also flags inline SVG icons that hardcode a color instead of using `currentColor`/a token. Pass `compact: true` to return only scores, violations, and fix_priority (drops embedded base64 screenshots) when the full payload is too large. |
+| `score_page` | Return a per-category (0–10) design score for a page — typography, accessibility, spacing, color, responsive layout, design tokens, structure — derived from the same checks as `audit_page`, plus the overall score/grade, the weakest category, and categories Raven does not mechanically assess (brand, conversion, motion) |
+| `audit_layout` | Evaluate visual rhythm, alignment, and optical balance; detects orphan-stretch (a lonely last-row grid/flex card stretching far wider than siblings) |
 | `audit_responsive_visibility` | Render a URL at multiple breakpoints and flag content elements that are visible on desktop but hidden on mobile (display:none/opacity:0/zero-size) — categorises each as likely-oversight (content vanishing on mobile) vs intentional (decorative) |
 | `audit_contrast` | Compute WCAG contrast ratios for every text element on a rendered page and report AA (4.5:1 / 3:1 large) and AAA pass-fail per element, with delta-to-pass for failures |
 | `suggest_contrast_fix` | Given failing WCAG color pairs, return the minimal fg/bg change that clears the AA/AAA target — concrete passing values to fix `audit_contrast` failures |
@@ -73,6 +74,8 @@ cd raven-mcp && npm install && npm run build
 | `audit_typography` | Typographic-**scale** report over rendered DOM text nodes (or a supplied snapshot) — detects the dominant modular-scale ratio and flags off-scale sizes, checks line-height consistency vs the body rhythm, and flags weight ladders >4 weights or non-standard values. Goes beyond `audit_page`'s pass/fail typography checks |
 | `audit_tap_targets` | WCAG 2.5.5 / Apple 44pt **web** tap-target audit — enumerates every interactive element (rendered URL or snapshot) and emits a per-element fix table: selector, role, text, measured w/h, per-axis pixel deficit, and a concrete CSS fix, sorted worst-first |
 | `audit_device_frame` | Flag cropped content in device-mockup frames — `frames` (container box + intrinsic media + object-fit, or a DevTools snippet) detects object-fit:cover crop loss when frame AR ≠ media AR; `clips` (first/last frame PNGs) detects baked-in pan/zoom (Ken Burns); `edge_frames` (PNGs) flags content truncated at a frame edge |
+| `audit_video_playback` | Render a page and observe whether each `<video>` actually advances — samples currentTime, readyState, error codes, and autoplay-block state, then classifies each clip into playing | paused | stalled | empty | error with evidence. Catches black/non-playing videos that static frame-capture audits miss. Pass `url` to render and observe, or `dom_snapshot` for deterministic offline classification |
+| `audit_consistency` | Corpus/multi-page audit — compares ≥2 pages and flags cross-page divergence in content-container width and hero heading tier, inferring the canonical (modal) value from the corpus when no token is supplied — catching relational defects that single-page audits miss |
 | `audit_swiftui` | Audit SwiftUI source against Apple HIG — Dynamic Type, semantic colors, 44pt targets, 4/8pt spacing, AccentColor |
 | `audit_ios_screen` | Score a rendered iOS screen from an accessibility/view-hierarchy snapshot — 44pt targets + contrast + rhythm, in points |
 | `audit_ios_privacy` | Audit Info.plist (or Expo app.json) /PRIVACY.md/entitlements/source — usage-string honesty, ATS, Android permissions, bundled secrets, undisclosed default data-egress |
@@ -101,6 +104,11 @@ cd raven-mcp && npm install && npm run build
 | `list_generation_jobs` | List local creative generation jobs |
 | `plan_creative_campaign` | Plan a multi-asset campaign and optionally create draft generation jobs |
 | `score_creative` | Score a prompt/script/concept for hook, benefit clarity, product signal, CTA, channel fit, audience fit, and brand fit |
+| `create_taste_profile` | Create a named taste profile — a portable design-judgment ruleset (rule_id, clause, category, severity, negative prompt, owner) + precedent corpus, from explicit rules and/or a DESIGN.md-style markdown doc — persisted locally under `~/.raven/taste/` (`RAVEN_TASTE_HOME` override) |
+| `get_taste_profile` | Load a stored taste profile's full rule catalog and precedent corpus |
+| `list_taste_profiles` | List locally stored taste profiles with rule/corpus counts |
+| `label_finding` | Append a human accept/revise/reject precedent to a profile's corpus — the growth loop; append-only, and accept-verdicts suppress that pattern in future audits |
+| `audit_taste` | Judge HTML, copy text, or a live URL against a taste profile — deterministic detectors for gradients, glow/neon, second accent hue, and banned words; `owner: raven` rules route through Raven's existing page/contrast/tap-target engines; every finding cites a rule_id + concrete evidence (undetectable clauses are reported as `not_assessed`, never guessed); verdict BLOCK / WARN / PASS |
 | `raven_reflect` | Summarize your local Raven usage log to find patterns + gaps |
 
 ## Creative studio

package/dist/index.js

@@ -7,6 +7,7 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { capturePage, CaptureUnavailableError, annotateVideoArtifacts, verifyFindings } from "./capture.js";
 import { runPageChecks } from "./page-checks.js";
+import { scorePage } from "./score-page.js";
 import { auditUrl } from "./audit-url.js";
 import { captureResponsiveVisibility } from "./responsive.js";
 import { auditContrastUrl, auditContrastSnapshot, suggestContrastFix } from "./contrast.js";
@@ -21,6 +22,10 @@ import { auditDeviceFrames, auditClipMotion, auditFrameEdges } from "./device-fr
 import { auditTypographyUrl, auditTypographySnapshot } from "./typography.js";
 import { auditTapTargetsUrl, auditTapTargetsSnapshot } from "./tap-targets.js";
 import { compactAuditPage, compactEvaluation, compactAuditUrl } from "./compact.js";
+import { auditVideoPlaybackUrl, auditVideoPlaybackSnapshot } from "./video-playback.js";
+import { auditConsistency } from "./audit-consistency.js";
+import { detectOrphanStretch } from "./layout-orphans.js";
+import { createTasteProfile, getTasteProfile, listTasteProfiles, labelFinding, auditTaste } from "./taste.js";
 // ── Path setup ──────────────────────────────────────────────────────
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var PKG_ROOT = join(__dirname, "..");
@@ -926,6 +931,31 @@ function extractInsight(toolName, input, output) {
             case "raven_reflect":
                 insight = { action: toolName };
                 break;
+            case "create_taste_profile": {
+                var tasteText = output?.content?.[0]?.text || "";
+                var tasteOut = JSON.parse(tasteText);
+                insight = { name: safeStr(input?.name, 32), rules: tasteOut.rules, corpus: tasteOut.corpus };
+                break;
+            }
+            case "get_taste_profile":
+            case "list_taste_profiles":
+                insight = { action: toolName, name: safeStr(input?.name, 32) };
+                break;
+            case "label_finding":
+                insight = { profile: safeStr(input?.profile, 32), verdict: input?.verdict, rule: safeStr(input?.violated_rule, 48) };
+                break;
+            case "audit_taste": {
+                var atText = output?.content?.[0]?.text || "";
+                var atOut = JSON.parse(atText);
+                insight = {
+                    profile: safeStr(input?.profile, 32),
+                    verdict: atOut.verdict,
+                    findings: (atOut.findings || []).map(function (f) { return f.rule_id; }),
+                    suppressed: (atOut.suppressed || []).length,
+                    not_assessed: (atOut.not_assessed || []).length
+                };
+                break;
+            }
             default:
                 insight = {};
         }
@@ -2194,6 +2224,28 @@ server.tool("audit_page", "Audit HTML/CSS against Raven's design quality standar
             }]
     };
 });
+// ── Tool 11b: score_page ───────────────────────────────────────────────────
+server.tool("score_page", "Score an HTML/CSS page across 7 design categories (Structure, Typography, Color & palette, Spacing & rhythm, Accessibility, Responsive layout, Design tokens), each rated 0–10. Scores are derived deterministically from the same checks as audit_page — no browser required. Also returns the same overall 0–100 score and A–D grade audit_page produces, the weakest category, and the three categories Raven does not mechanically assess (brand, conversion, motion) with guidance on which tools to use for those.", {
+    html: z.string().min(1).describe("The full HTML content of the page to score."),
+    strict: z.boolean().optional().describe("Strict mode — count warnings as failures in the overall score. Default: false."),
+    containerMaxWidth: z.number().optional().describe("Your design system's canonical content-container width in px (e.g. 1152). Forwarded to the responsive/max-width check.")
+}, async function ({ html, strict, containerMaxWidth }) {
+    if (html === undefined || html === null || html.trim() === "") {
+        return {
+            content: [{
+                    type: "text",
+                    text: "Provide html (the page's HTML/CSS) to score."
+                }]
+        };
+    }
+    const result = scorePage(html, { strict, containerMaxWidth });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }]
+    };
+});
 server.tool("audit_asset_integrity", "Detect PNG exports whose content is sliced/cut off at the bottom edge (e.g. a Figma export that ended mid-form). Dimension/ratio checks cannot catch cut content inside a correctly-sized file; this measures per-pixel luminance variance in the bottom strip — uniform background = clean, high-variance UI content running into the edge = likely-sliced. Accepts filesystem paths to PNGs.", { image_paths: z.array(z.string()).describe("Filesystem paths to PNG files to check for sliced/cut-off bottom content.") }, async function ({ image_paths }) {
     var results = await auditAssetIntegrity(image_paths || []);
     return { content: [{ type: "text", text: JSON.stringify({ tool: "audit_asset_integrity", results: results }, null, 2) }] };
@@ -3236,6 +3288,7 @@ server.tool("audit_layout", "Evaluate visual rhythm from a rendered page's geome
     else {
         findings.push({ check: "optical-balance", status: "warn", message: "Layout is " + (leftWeight > rightWeight ? "left-heavy" : "right-heavy") + " — visual weight skewed by " + Math.round(balanceSkew * 100) + "%", fix: balanceSkew > 0.4 ? "Redistribute dense blocks (images, tables) toward center, or add counterweight on the lighter side." : "Minor imbalance — review whether it's intentional asymmetry or accidental." });
     }
+    var orphanStretch = detectOrphanStretch(elements);
     return {
         content: [{
                 type: "text",
@@ -3247,7 +3300,8 @@ server.tool("audit_layout", "Evaluate visual rhythm from a rendered page's geome
                         alignment: { total_columns: colCounts.size, shared_columns: sharedCols, singleton_columns: singletonCols, aligned_ratio: Number(alignmentRatio.toFixed(2)) },
                         gap_rhythm: vGaps.length >= 3 ? { samples: vGaps.length, median_px: Math.round(gapMedian), stdev_px: Math.round(gapStdev), coef_variation: Number(gapCV.toFixed(2)) } : { samples: vGaps.length, note: "not enough horizontally-overlapping vertical sibling pairs" },
                         balance: { left_weight: Math.round(leftWeight), right_weight: Math.round(rightWeight), skew_pct: Math.round(balanceSkew * 100) }
-                    }
+                    },
+                    orphan_stretch: orphanStretch
                 }, null, 2)
             }]
     };
@@ -4700,6 +4754,38 @@ server.tool("score_creative", "Score a creative prompt, script, or ad concept fo
     var result = scoreCreativeText(params.creative_text, params.channel, brand, audience);
     return { content: [{ type: "text", text: JSON.stringify({ ...result, channel: params.channel || null, audience: audience || null, brand_profile_id: brand ? brand.id : null }, null, 2) }] };
 });
+// ── Cross-page consistency audit ─────────────────────────────────────
+// audit_consistency: takes ≥2 pages ({name, html}) and flags divergence in
+// content-container width and hero heading tier across the corpus. Addresses
+// GitHub issue #9 — the single-blob audit blind spot where each page passes
+// audit_page clean but the pages disagree with each other.
+server.tool("audit_consistency", "Audit multiple pages for cross-page consistency of content-container width and hero heading tier. Pass ≥2 pages ({name, html}) collected from different routes on the same site. Infers the canonical (modal) value from the corpus when no token is supplied, so you need not know the project's design token in advance. Flags the issue #9 single-blob blind spot: pages that each pass audit_page but silently disagree with each other on container width or hero size class. Returns per-page extraction (container_px, container_classes, hero_classes, signatures), consistency dimensions with reference values, outlier page names, issues[], score (100/50/0 → A/C/D), and a plain-text summary. Pure offline — no browser, no network.", {
+    pages: z.array(z.object({
+        name: z.string().min(1).describe("Page route or label (e.g. \"/\", \"/changelog\", \"get-started\")."),
+        html: z.string().min(1).describe("Full HTML source for the page, including any <style> blocks.")
+    })).min(2).describe("At least 2 pages to compare. Each entry is {name, html}."),
+    container_token: z.number().optional().describe("Project's canonical container width in px (e.g. 1152). When supplied, container divergence is measured against this token rather than the corpus modal."),
+    hero_token: z.string().optional().describe("Canonical hero heading class signature (e.g. \"text-display-xl\" or \"64\"). When supplied, hero divergence is measured against this token rather than the corpus modal.")
+}, async function (params) {
+    if (!params.pages || params.pages.length < 2) {
+        return {
+            content: [{
+                    type: "text",
+                    text: "Provide at least 2 pages ({name, html}) to compare for cross-page consistency."
+                }]
+        };
+    }
+    var result = auditConsistency(params.pages, {
+        container_token: params.container_token,
+        hero_token: params.hero_token
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }]
+    };
+});
 // ── Reflection ─────────────────────────────────────────────────────
 // Summarize the local usage log so the user (or Claude acting on their
 // behalf) can see what Raven is being asked to do, and what it's often
@@ -4812,6 +4898,134 @@ server.tool("raven_register", "Register your email to receive design updates and
         };
     }
 });
+// ── Tool 57: audit_video_playback ─────────────────────────────────
+server.tool("audit_video_playback", "Render a page in headless Chromium and observe whether each <video> actually advances (samples currentTime before/after a play attempt), classifying every clip into playing|paused|stalled|empty|error with a reason. Catches black/non-playing videos that static audits miss — the most common real-world defect on marketing sites with video backgrounds. Pass url to render + observe, or dom_snapshot to classify pre-collected observations without a browser.", {
+    url: z.string().optional().describe("URL to render and observe (http/https or file://). Requires headless chromium."),
+    dom_snapshot: z.array(z.object({
+        selector: z.string().describe("CSS selector identifying the video element"),
+        hasSource: z.boolean().describe("True if currentSrc is non-empty OR the element has a src attribute or <source> child"),
+        readyState: z.number().describe("HTMLMediaElement.readyState (0..4)"),
+        networkState: z.number().describe("HTMLMediaElement.networkState (0..3; 3=NETWORK_NO_SOURCE)"),
+        errorCode: z.number().describe("MediaError.code (0=none, 1=aborted, 2=network, 3=decode, 4=src-not-supported)"),
+        paused: z.boolean().describe("True if the element is paused"),
+        autoplayBlocked: z.boolean().describe("True if play() was rejected with NotAllowedError"),
+        currentTimeStart: z.number().describe("currentTime recorded before the play attempt"),
+        currentTimeEnd: z.number().describe("currentTime recorded after the observe window")
+    })).optional().describe("Pre-collected video observations to classify without rendering (deterministic path)"),
+    observeMs: z.number().optional().describe("Milliseconds to wait between currentTime samples after play() attempt. Default: 1000")
+}, async function ({ url, dom_snapshot, observeMs }) {
+    if (url !== undefined && url !== null) {
+        try {
+            var vr = await auditVideoPlaybackUrl(url, { observeMs: observeMs });
+            return { content: [{ type: "text", text: JSON.stringify(vr, null, 2) }] };
+        }
+        catch (error) {
+            if (error instanceof CaptureUnavailableError) {
+                return { content: [{ type: "text", text: "audit_video_playback url mode needs headless chromium. Run: npx playwright install chromium — or pass a dom_snapshot instead." }] };
+            }
+            throw error;
+        }
+    }
+    if (dom_snapshot !== undefined && dom_snapshot !== null) {
+        // Same aggregator the browser path uses → identical VideoPlaybackResult
+        // shape (url is null since no page was rendered).
+        var snapResult = auditVideoPlaybackSnapshot(dom_snapshot, null);
+        return { content: [{ type: "text", text: JSON.stringify(snapResult, null, 2) }] };
+    }
+    return { content: [{ type: "text", text: "Provide either url (render + observe) or dom_snapshot (classify supplied observations). See tool schema for dom_snapshot field shapes." }] };
+});
+// ── Taste Engine: profiles, growth loop, and taste audits ──────────────────
+server.tool("create_taste_profile", "Create (or overwrite) a named taste profile — a portable design-judgment ruleset + precedent corpus persisted locally under ~/.raven/taste/<name>.json (override dir with RAVEN_TASTE_HOME). Pass explicit rules[] (rule_id, clause_text, category, severity_default block|warn|nit, negative_prompt, owner taste|raven, delegate_to), and/or a DESIGN.md-style markdown doc to ingest (## headings = categories; '- ' bullets = rules; '(block)'/'(warn)'/'(nit)' severity markers; '(raven:<tool>)' delegates a rule to an existing Raven audit tool; 'Do NOT …' sentences become the rule's negative prompt). Ingest RULES-SHAPED docs only (actionable design constraints under category headings) — brand-story/mythology docs produce noise rules, not judgment. Local-first: nothing leaves the machine.", {
+    name: z.string().min(1).describe("Profile name (becomes <name>.json; lowercase alnum/dash/underscore)."),
+    rules: z.array(z.object({
+        rule_id: z.string().describe("Stable unique id, e.g. COLOR-no-gradient."),
+        clause_text: z.string().describe("The rule stated as a positive clause."),
+        category: z.string().describe("color | typography | layout | spacing | voice | tokens | motion | …"),
+        severity_default: z.enum(["block", "warn", "nit"]),
+        negative_prompt: z.string().optional().describe("'Do NOT …' phrasing. A parenthesized comma-list becomes a deterministic banned-word scan ONLY when its sentence is about vocabulary (use/say/write/words/verbs/phrases…), e.g. 'Do NOT use persuasion verbs (proven, shipped, unlock)'. Descriptive example lists ('project facts (counts, scope)') are ignored."),
+        owner: z.enum(["taste", "raven"]).optional().describe("raven = measured by an existing Raven audit tool named in delegate_to."),
+        delegate_to: z.string().optional().describe("Raven tool that owns the measurement (required when owner is raven).")
+    })).optional().describe("Explicit rule objects."),
+    corpus: z.array(z.object({
+        artifact: z.string(),
+        verdict: z.enum(["accept", "revise", "reject"]),
+        violated_rule: z.string(),
+        severity: z.enum(["block", "warn", "nit"]).optional(),
+        wrong: z.string(),
+        right: z.string()
+    })).optional().describe("Seed precedent records."),
+    markdown: z.string().optional().describe("DESIGN.md-style markdown to ingest as rules.")
+}, async function ({ name, rules, corpus, markdown }) {
+    var profile = createTasteProfile({ name: name, rules: rules, corpus: corpus, markdown: markdown });
+    return { content: [{ type: "text", text: JSON.stringify({ tool: "create_taste_profile", name: profile.name, rules: profile.rules.length, corpus: profile.corpus.length, home: process.env.RAVEN_TASTE_HOME ? "RAVEN_TASTE_HOME" : "~/.raven/taste" }, null, 2) }] };
+});
+server.tool("get_taste_profile", "Load a locally stored taste profile by name — returns its full rule catalog and precedent corpus.", { name: z.string().min(1).describe("Profile name.") }, async function ({ name }) {
+    return { content: [{ type: "text", text: JSON.stringify(getTasteProfile(name), null, 2) }] };
+});
+server.tool("list_taste_profiles", "List locally stored taste profiles with rule/corpus counts and last-updated timestamps.", {}, async function () {
+    return { content: [{ type: "text", text: JSON.stringify({ tool: "list_taste_profiles", profiles: listTasteProfiles() }, null, 2) }] };
+});
+server.tool("label_finding", "Append a labeled precedent to a taste profile's corpus — the growth loop. Use when a human accepts/revises/rejects an audit_taste finding or labels a new wrong→right example. Append-only: existing records are never rewritten. accept-verdict precedents suppress matching findings in future audit_taste runs.", {
+    profile: z.string().min(1).describe("Profile name."),
+    artifact: z.string().describe("What was judged (path, URL, or short description)."),
+    verdict: z.enum(["accept", "revise", "reject"]).describe("accept = the flagged pattern is fine (suppresses future matches); revise/reject = confirmed wrong."),
+    violated_rule: z.string().describe("The rule_id the label concerns ('' if none). Must exist in the profile."),
+    severity: z.enum(["block", "warn", "nit"]).optional().describe("Severity the human assigns."),
+    wrong: z.string().describe("The wrong pattern — use a verbatim snippet so accept-suppression can match it."),
+    right: z.string().describe("What right looks like.")
+}, async function ({ profile, artifact, verdict, violated_rule, severity, wrong, right }) {
+    var res = labelFinding(profile, { artifact: artifact, verdict: verdict, violated_rule: violated_rule, severity: severity || "", wrong: wrong, right: right });
+    return { content: [{ type: "text", text: JSON.stringify({ tool: "label_finding", profile: res.profile, corpus_count: res.corpus_count, record: res.record }, null, 2) }] };
+});
+server.tool("audit_taste", "Judge a target against a taste profile. Pass html (static page/CSS), text (a copy block), or url (rendered headless; also runs delegated WCAG-contrast/tap-target measurements for owner:raven rules). owner:taste rules run deterministic detectors — gradients, glow/neon (large-blur colored shadows), second accent hue, banned-word lists from the rule's negative prompt; clauses with no deterministic detector are reported honestly under not_assessed instead of guessed. owner:raven rules route through Raven's existing audit engines (page checks, contrast, tap targets) and fold results in under the delegating rule_id. Every finding cites an existing rule_id + concrete evidence — the engine prefers silence over a speculative nit. accept-verdict corpus precedents suppress previously-approved patterns. Verdict: BLOCK (any block finding) / WARN (any warn) / PASS.", {
+    profile: z.string().min(1).describe("Taste profile name (see list_taste_profiles)."),
+    html: z.string().optional().describe("Full HTML/CSS of the page to judge."),
+    text: z.string().optional().describe("A copy/text block to judge (voice/banned-word rules)."),
+    url: z.string().optional().describe("Live URL — rendered headless with scroll-settle; enables delegated contrast/tap-target measurement.")
+}, async function ({ profile, html, text, url }) {
+    if (typeof url === "string" && url.trim() === "")
+        url = undefined;
+    var providedInputs = [html !== undefined, text !== undefined, url !== undefined].filter(Boolean).length;
+    if (providedInputs !== 1) {
+        return { content: [{ type: "text", text: "Provide exactly one of html, text, or url to judge (got " + providedInputs + ")." }] };
+    }
+    var prof = getTasteProfile(profile);
+    var targetHtml = html;
+    var pageIssues = [];
+    var delegates = new Set(prof.rules.filter(function (r) { return r.owner === "raven"; }).map(function (r) { return r.delegate_to; }));
+    if (url) {
+        try {
+            var cap = await capturePage(url, { scroll_settle: true });
+            targetHtml = cap.renderedHtml;
+            if (delegates.has("audit_contrast")) {
+                var c = await auditContrastUrl(url);
+                for (var row of c.aa_failures)
+                    pageIssues.push({ rule: "contrast/aa", severity: "error", message: row.selector + " \"" + row.text.slice(0, 40) + "\" contrast " + row.ratio + ":1 < required " + row.required_aa + ":1 (fg " + row.foreground + " on bg " + row.background + ")", fix: "Adjust fg/bg to clear " + row.required_aa + ":1 (delta " + row.delta_to_aa + ")." });
+            }
+            if (delegates.has("audit_tap_targets")) {
+                var t = await auditTapTargetsUrl(url);
+                for (var trow of t.fix_table)
+                    pageIssues.push({ rule: "tap-targets/min-size", severity: "error", message: trow.selector + " (" + trow.role + ") " + trow.w + "x" + trow.h + "px below minimum", fix: trow.fix });
+            }
+        }
+        catch (error) {
+            if (error instanceof CaptureUnavailableError) {
+                return { content: [{ type: "text", text: "audit_taste url mode needs headless chromium. Run: npx playwright install chromium — or pass the page's html instead." }] };
+            }
+            throw error;
+        }
+    }
+    if (targetHtml && delegates.has("audit_page")) {
+        var pc = runPageChecks(targetHtml);
+        for (var iss of pc.issues)
+            pageIssues.push({ rule: iss.rule, severity: iss.severity, message: iss.message, fix: iss.fix });
+    }
+    var result = auditTaste({ profile: prof, html: targetHtml, text: targetHtml === undefined ? text : undefined, page_issues: pageIssues.length > 0 ? pageIssues : undefined });
+    var out = result;
+    if (url)
+        out = Object.assign({}, result, { target: "url", url: url });
+    return { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] };
+});
 // ── Start ───────────────────────────────────────────────────────────
 async function main() {
     var transport = new StdioServerTransport();