code-factory-4-design 0.3.0__py3-none-any.whl

code_factory_4_design-0.3.0.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: code-factory-4-design
+Version: 0.3.0
+Summary: The Digital Architect of Prestige — a coding-agent skill for designing premium, high-conversion websites and mobile UIs using applied psychology and trust engineering. Ships a SKILL.md contract plus an executable design-linter that audits generated HTML/CSS against the Halo Effect, Cognitive Fluency, Trust Engineering, Peak-End Rule, and Horn-Effect triggers.
+License-Expression: MIT OR Apache-2.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE-APACHE
+License-File: LICENSE-MIT
+License-File: NOTICE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# The Digital Architect of Prestige 💎
+
+A **coding-agent skill** for designing premium, high-conversion websites and
+mobile UIs — for Claude Code, Codex, OpenCode, Cursor, and any agent that reads
+a project skill file. It moves the agent beyond aesthetics into **applied
+psychology and trust engineering**, and ships an **executable design linter** so
+the agent can *verify* its output against the principles, not just intend them.
+
+> Users judge credibility in ~50ms from visuals alone. If it looks
+> professional, they assume the service is too (the Halo Effect). This skill
+> engineers that halo — and refuses to let a pretty page ship over a broken one.
+
+## Workflow at a glance
+
+```mermaid
+flowchart LR
+    A["User journey or page brief"] --> B["Select workflow and purpose"]
+    B --> C["Build premium UI"]
+    C --> D["Audit five laws"]
+    D --> E["Score bias, CTA, hook, mobile, and purpose fit"]
+    E -->|"fails"| F["Fix ranked recommendations"]
+    F --> D
+    E -->|"passes"| G["Ship UI with design receipt"]
+```
+
+## Install into your agent (any OS)
+
+```bash
+python install.py                 # Windows / macOS / Linux (installs + verifies)
+# then, inside your project:
+prestige install claude           # or: codex · opencode · cursor · generic
+```
+That drops `SKILL.md` where your agent auto-reads it. From then on, any
+"design a landing page / make this premium / build a checkout" request triggers
+the skill.
+
+## What the agent gets
+
+**A design contract (`SKILL.md`)** encoding five laws it applies every time:
+
+1. **The 50ms Halo** — hero section, one bold headline, high-fidelity cover imagery.
+2. **Cognitive Fluency** — Hick's/Miller's Law, extreme whitespace, one goal per section, `line-height ≥ 1.6`.
+3. **Trust Engineering** — security + social-proof cues at decision points, total price incl. fees upfront, guest checkout.
+4. **Peak-End Rule** — micro-interactions at the peaks, inline form validation, a rewarding confirmation ending.
+5. **Horn-Effect Defense** — one Visual DNA in CSS variables, mobile-first stability, no dated cues.
+
+**An executable linter (`prestige audit`)** that scores generated HTML/CSS on all
+five laws and **hard-fails on major functional flaws** — because the skill's one
+non-negotiable rule is *never let aesthetics mask a broken primary action or an
+inaccessible UI.*
+
+```bash
+prestige scaffold site.html        # premium starter (scores 100/100)
+prestige audit site.html           # score the five laws + catch Horn-Effect triggers
+prestige purpose site.html --purpose developer  # opinionated purpose-fit audit
+prestige audit site.html --strict  # exit 1 if failing — use as an agent/CI gate
+```
+
+Example on a deliberately clunky page:
+```
+Overall: 18/100   Verdict: NEEDS WORK
+halo:15  fluency:20  trust:20  peak:20  horn:15
+⛔ HARD FAILURES (fix before shipping — function over aesthetics):
+   MAJOR_FLAW: primary action button has no accessible label/text.
+   ✗ [trust] T_NO_SECURITY: Transactional UI with no security cue near actions.
+   ✗ [horn]  C_NO_VIEWPORT: Missing viewport meta — mobile layout will break.
+```
+
+## The workflow the skill teaches
+
+`Discovery` (audit the journey for trust gaps) → `Build` (apply the five laws)
+→ `Verify` (`prestige audit`, fix flags, then present). The agent treats a
+failing audit like a failing test — which is exactly how "premium" stops being
+a vibe and becomes a checkable property.
+
+## The psychology, sourced
+Halo Effect & the 50ms window · Aesthetic-Usability Effect · Hick's & Miller's
+Law · Fitts's Law · Peak-End Rule · Negativity/Horn Effect. Detailed playbooks
+in `references/` (hero-halo, cognitive-fluency, trust-engineering, peak-end).
+
+## v0.2 — deeper psychology, stricter scoring, five workflows
+
+- **Cognitive Bias Engine** — six research-backed biases (Von Restorff, Anchoring,
+  Social Proof, Loss Aversion, Reciprocity, Cognitive Fluency) with detectors,
+  quality scoring, and precise recommendations.
+- **CTA & Hook Verification** — scores whether your call-to-action and headline
+  are engineered to convert (weak-verb detection, reader-focus, power words,
+  CTA-competition penalty) with exact rewrites.
+- **Strict Mobile Judge** — thumb-reach tap targets, viewport discipline, real
+  breakpoints, legible base text, sticky-CTA guidance — because trust breaks on
+  mobile first.
+- **Five Design-Principle Workflows** — Conversion Architect, Luxury Minimalist,
+  Trust Engineer, Editorial Storyteller, Product-Led Pragmatist. Each is a
+  distinct optimization strategy that re-weights the score.
+- **Precision Scoring** — `prestige score <file> --workflow <key>` fuses laws +
+  biases + CTA/hooks + mobile into a 0–100 conversion-readiness grade with
+  **recommendations ranked by conversion impact**.
+
+```bash
+prestige workflows                          # see the five lenses
+prestige score site.html --workflow trust   # precise score + ranked fixes
+prestige score site.html --strict           # exit 1 if not conversion-ready
+```
+
+Grounded in current research: credibility forms in ~0.05s (Google), trigger-driven
+UX lifts conversion ~34% on average (Nielsen Norman 2024).
+
+## v0.3 - purpose-fit design judgment
+
+Workflows answer **what the page optimizes for**. Purpose lenses answer **what
+psychological job the design must do for this audience and domain**.
+
+Prestige now ships deterministic purpose-fit profiles:
+
+- `developer` - concrete proof, docs, CLI/API clarity, GitHub/demo trust.
+- `healthcare` - calm reassurance, privacy, clinician proof, no miracle hype.
+- `fintech` - security, transparent fees/rates, control, compliance cues.
+- `luxury` - restraint, craft, whitespace, fewer louder elements.
+- `marketplace` - bilateral buyer/seller trust, reviews, protection, comparison.
+- `saas` - product visibility, integrations, ROI, low-friction activation.
+- `editorial` - narrative rhythm, sources, evidence, satisfying end beat.
+
+```bash
+prestige purposes
+prestige purpose site.html --purpose healthcare --strict
+prestige score site.html --workflow trust --purpose healthcare
+```
+
+The purpose gate scores intent clarity, proof fit, visual theme fit, action
+language, and purpose-specific anti-patterns. This makes Prestige more
+opinionated in the right way: not just "pretty," but fit for the decision the
+interface exists to change.
+
+## License
+Dual-licensed **Apache-2.0 OR MIT** — pick whichever your project prefers.
+## Criterion attribution
+
+Prestige 0.2.1 wraps its existing five per-law scores in the factory attribution
+envelope. Run `prestige audit page.html --json` to receive one unit per design
+criterion, its score and threshold, and the unchanged overall verdict.

code_factory_4_design-0.3.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+code_factory_4_design-0.3.0.dist-info/licenses/LICENSE-APACHE,sha256=7E7Abez5cUuQccTXlM_Tcx4MlEraqeuGX67rlx1dOyQ,487
+code_factory_4_design-0.3.0.dist-info/licenses/LICENSE-MIT,sha256=R_78kakzZsivM3qr_yf5z3A9FAz8vdBkt7J75-mrjJI,499
+code_factory_4_design-0.3.0.dist-info/licenses/NOTICE,sha256=cj5FLrj-XYK-uwnkiggsRV62mzjmdCY6gkylrDscdoY,160
+prestige_design/__init__.py,sha256=R1Th69fyPr-4k0hc9v2t1QxNgAz5lbGq1rfQ8xkgYK0,833
+prestige_design/adapters.py,sha256=6lmJivNajewaFY0B4LAqvb6940G_l-PLwvSxIJ7Yj2E,1104
+prestige_design/attribution.py,sha256=U4861YtbeHgj9iKNutAdYrRJ7xH4K95ET2InqzC1ntU,1471
+prestige_design/audit.py,sha256=E435nynFautddK_Xf18_vOOqobS5IJaDhzl_M7ROm-U,8608
+prestige_design/biases.py,sha256=NMQRGt4b293xn9Oc5gLaqg8iQzIoK0l4Ccc__yg5kE4,7592
+prestige_design/cli.py,sha256=I6rI08R2Dm7ItR8EXkwxCj1VzomH2_PGTi5ELN6EUo0,11081
+prestige_design/cta_hooks.py,sha256=jvfOPAE9DA2Rj0x17oeXwvYIG4Vg3nUrpDkrvB3-foI,4901
+prestige_design/mobile_judge.py,sha256=pE8I771JDhN2b40CoWQZcwU3ze1gV-KgiDhLz-fVeFo,3100
+prestige_design/purpose.py,sha256=sSje9XH-W6ZtZCJNRNVwlZfBoedVu-bqUylpc3zqjqw,13320
+prestige_design/score.py,sha256=va8xFyKaYbQHncBznhE7iUotl2zBqLEqGomjTe3szWg,5284
+prestige_design/workflows.py,sha256=v3yQNrYlJYgvKXBUF_24-S_HxyLNzRG4ozQBHP4bsMU,5657
+code_factory_4_design-0.3.0.dist-info/METADATA,sha256=X4hQyLMeXQ6mHzi-wD6gbuls5jCbHd1DrQNlORRdpAQ,7540
+code_factory_4_design-0.3.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+code_factory_4_design-0.3.0.dist-info/entry_points.txt,sha256=WX3IpwEGRfVagRGz_CWcwOcEngfm4-mO_dOoj63AbSA,54
+code_factory_4_design-0.3.0.dist-info/top_level.txt,sha256=wSDpQ6UwJGuiscsml8WKqaWUchughfGx53IxsFGQQP4,16
+code_factory_4_design-0.3.0.dist-info/RECORD,,

code_factory_4_design-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

code_factory_4_design-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+prestige = prestige_design.cli:main

code_factory_4_design-0.3.0.dist-info/licenses/LICENSE-APACHE

@@ -0,0 +1,8 @@
+                                 Apache License
+                           Version 2.0, January 2004
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy at http://www.apache.org/licenses/LICENSE-2.0
+   Distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND. Full text: http://www.apache.org/licenses/LICENSE-2.0.txt
+   Copyright 2026 WizeMe.APP

code_factory_4_design-0.3.0.dist-info/licenses/LICENSE-MIT

@@ -0,0 +1,10 @@
+MIT License
+
+Copyright (c) 2026 WizeMe.APP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including the rights to use, copy, modify,
+merge, publish, distribute, sublicense, and/or sell copies, subject to
+including the above notice. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY
+OF ANY KIND. Full text: https://opensource.org/licenses/MIT

code_factory_4_design-0.3.0.dist-info/licenses/NOTICE

@@ -0,0 +1,3 @@
+The Digital Architect of Prestige — premium design skill for coding agents
+Copyright 2026 WizeMe.APP
+Dual-licensed under Apache-2.0 OR MIT at your option.

code_factory_4_design-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+prestige_design

prestige_design/__init__.py

@@ -0,0 +1,15 @@
+"""The Digital Architect of Prestige — premium web/mobile design as a skill.
+
+Encodes five design laws as an executable audit so any coding agent (Claude
+Code / Codex / OpenCode / Cursor / …) doesn't just *know* the principles but
+can *verify* its own output before shipping:
+
+  1. The 50ms Halo        — hero section, high-fidelity imagery, instant credibility
+  2. Cognitive Fluency    — Hick's/Miller's Law, whitespace, one goal per section
+  3. Trust Engineering    — security cues + social proof at decision points, price transparency
+  4. Peak-End Rule        — micro-interactions at peaks, a rewarding conclusion
+  5. Horn-Effect Defense  — ruthless consistency, mobile stability, no dated cues
+
+The warning is enforced too: aesthetics never mask a MAJOR functional flaw.
+"""
+__version__ = "0.3.0"

prestige_design/adapters.py

@@ -0,0 +1,28 @@
+"""Install this skill into any coding agent. The SKILL.md is the contract;
+each agent reads it from a different location."""
+from __future__ import annotations
+from pathlib import Path
+
+def skill_text() -> str:
+    return (Path(__file__).resolve().parent/"SKILL.md").read_text()
+
+TARGETS = {
+    "claude":   [".claude/skills/prestige-design/SKILL.md"],
+    "codex":    ["AGENTS.md"],           # appended, not overwritten
+    "opencode": [".opencode/skills/prestige-design.md"],
+    "cursor":   [".cursor/rules/prestige-design.md"],
+    "generic":  ["SKILL-prestige-design.md"],
+}
+
+def install(root: Path, agent: str) -> list[Path]:
+    root = Path(root); created = []
+    key = {"claude-code":"claude"}.get(agent, agent)
+    text = skill_text()
+    for rel in TARGETS.get(key, ["AGENTS.md"]):
+        dst = root/rel; dst.parent.mkdir(parents=True, exist_ok=True)
+        if dst.name == "AGENTS.md" and dst.exists():
+            dst.write_text(dst.read_text().rstrip()+"\n\n"+text)
+        else:
+            dst.write_text(text)
+        created.append(dst)
+    return created

prestige_design/attribution.py

@@ -0,0 +1,51 @@
+"""Attribution wrapper for Prestige's existing per-criterion scores."""
+from dataclasses import asdict, dataclass
+from enum import Enum
+
+
+class FailureClass(str, Enum):
+    AMBIGUOUS_REQUIREMENT = "ambiguous_requirement"
+    UNTYPED_INPUT = "untyped_input"
+    SCOPE_ESCAPE = "scope_escape"
+    INVENTED_PARAM = "invented_param"
+    SIGNATURE_DRIFT = "signature_drift"
+    STUB_UNFILLED = "stub_unfilled"
+    COMPLEXITY_EXCEEDED = "complexity_exceeded"
+    INCONSISTENT_LOGIC = "inconsistent_logic"
+    RUNTIME_CRASH = "runtime_crash"
+    RUNTIME_TIMEOUT = "runtime_timeout"
+    WRONG_OUTPUT = "wrong_output"
+    ACCURACY_REGRESSION = "accuracy_regression"
+    NONDETERMINISM = "nondeterminism"
+    SECURITY_FINDING = "security_finding"
+
+
+@dataclass(frozen=True)
+class UnitResult:
+    unit: str
+    stage: str
+    passed: bool
+    evidence: str
+    failure_class: FailureClass | None = None
+
+
+@dataclass
+class Attribution:
+    stage: str
+    n_checked: int
+    n_passed: int
+    units: list[UnitResult]
+
+    @property
+    def rate(self):
+        return self.n_passed / self.n_checked if self.n_checked else 0.0
+
+    def dominant_failure_class(self):
+        return FailureClass.WRONG_OUTPUT if self.n_passed < self.n_checked else None
+
+    def to_dict(self):
+        value = asdict(self)
+        value["rate"] = self.rate
+        dominant = self.dominant_failure_class()
+        value["dominant_failure_class"] = dominant.value if dominant else None
+        return value

prestige_design/audit.py

@@ -0,0 +1,148 @@
+"""The Prestige design linter — encodes the five laws as executable checks so
+an agent can VERIFY its output, not just intend it. Pure-stdlib HTML/CSS
+heuristics; no browser needed. Returns per-law scores + Horn-Effect triggers +
+hard failures for major functional flaws (the non-negotiable warning)."""
+from __future__ import annotations
+import re
+from dataclasses import dataclass, field
+
+@dataclass
+class Finding:
+    law: str
+    level: str          # "pass" | "warn" | "fail" | "hard_fail"
+    code: str
+    message: str
+
+@dataclass
+class AuditReport:
+    findings: list = field(default_factory=list)
+    scores: dict = field(default_factory=dict)      # law -> 0..100
+    hard_failures: list = field(default_factory=list)
+
+    @property
+    def passed(self) -> bool:
+        return not self.hard_failures and all(v >= 60 for v in self.scores.values())
+
+    @property
+    def overall(self) -> int:
+        return round(sum(self.scores.values()) / len(self.scores)) if self.scores else 0
+
+    @property
+    def attribution(self):
+        from .attribution import Attribution, FailureClass, UnitResult
+        units = [
+            UnitResult(
+                unit=f"criterion:{law}",
+                stage="design_audit",
+                passed=score >= 60,
+                evidence=f"score={score}; threshold=60",
+                failure_class=None if score >= 60 else FailureClass.WRONG_OUTPUT,
+            )
+            for law, score in sorted(self.scores.items())
+        ]
+        return Attribution("design_audit", len(units), sum(unit.passed for unit in units), units)
+
+def _has(pattern, text, flags=re.I):
+    return re.search(pattern, text, flags) is not None
+
+def _count(pattern, text, flags=re.I):
+    return len(re.findall(pattern, text, flags))
+
+def audit_html(html: str, css: str = "") -> AuditReport:
+    """css may be inline in html; we scan both together for style checks."""
+    blob = html + "\n" + css
+    style = css + "\n" + " ".join(re.findall(r"<style[^>]*>(.*?)</style>", html, re.S | re.I))
+    r = AuditReport()
+    f = r.findings
+
+    # ---------- LAW 1: 50ms Halo (hero) ----------
+    s = 100
+    has_hero = _has(r'class=["\'][^"\']*hero', html) or _has(r'<header', html) or _has(r'<section[^>]*hero', html)
+    if not has_hero:
+        s -= 40; f.append(Finding("halo","warn","H_NO_HERO","No identifiable hero/header section for the 50ms credibility window."))
+    if not _has(r'object-fit\s*:\s*cover', style) and not _has(r'background-size\s*:\s*cover', style):
+        s -= 20; f.append(Finding("halo","warn","H_NO_COVER_IMG","No object-fit/background cover image — hero imagery drives the halo."))
+    h1 = _count(r'<h1', html)
+    if h1 == 0:
+        s -= 25; f.append(Finding("halo","fail","H_NO_H1","No <h1> — the hero needs one bold headline."))
+    elif h1 > 1:
+        s -= 15; f.append(Finding("halo","warn","H_MULTI_H1",f"{h1} <h1> tags — a single bold headline signals confidence."))
+    r.scores["halo"] = max(s, 0)
+
+    # ---------- LAW 2: Cognitive Fluency ----------
+    s = 100
+    navlinks = _count(r'<nav[^>]*>.*?</nav>', html, re.S)
+    nav_items = 0
+    for nav in re.findall(r'<nav[^>]*>(.*?)</nav>', html, re.S | re.I):
+        nav_items = max(nav_items, _count(r'<a\b', nav))
+    if nav_items > 7:
+        s -= 25; f.append(Finding("fluency","warn","F_NAV_OVERLOAD",f"Primary nav has {nav_items} items (Hick's Law: keep ≤7)."))
+    if not _has(r'line-height\s*:\s*(1\.[6-9]|[2-9])', style):
+        s -= 20; f.append(Finding("fluency","warn","F_TIGHT_LEADING","Body line-height < 1.6 hurts readability/fluency."))
+    # whitespace: look for generous section padding
+    pads = re.findall(r'padding[^;:]*:\s*([0-9.]+)(rem|vw|vh|em|px)', style, re.I)
+    generous = any((u in ("rem","vw","em") and float(v) >= 3) or (u=="px" and float(v)>=48) for v,u in pads)
+    if not generous:
+        s -= 20; f.append(Finding("fluency","warn","F_NO_WHITESPACE","No generous section padding — extreme whitespace signals premium."))
+    if not _has(r'display\s*:\s*(grid|flex)', style):
+        s -= 15; f.append(Finding("fluency","warn","F_NO_CHUNKING","No grid/flex layout — use it to chunk info (Miller's Law)."))
+    r.scores["fluency"] = max(s, 0)
+
+    # ---------- LAW 3: Trust Engineering ----------
+    s = 100
+    trust_cues = _count(r'(secure|verified|guarantee|padlock|lock-icon|badge|ssl|encrypt|trusted)', blob)
+    social = _has(r'(review|rating|stars?|testimonial|★|⭐|\bfrom\s+\d+\s+reviews?)', blob)
+    is_transactional = _has(r'(checkout|buy|purchase|book now|subscribe|sign\s*up|pay\b|add to cart|price|\$\d)', blob)
+    if is_transactional:
+        if trust_cues == 0:
+            s -= 35; f.append(Finding("trust","fail","T_NO_SECURITY","Transactional UI with no security/verification cue near actions."))
+        if not social:
+            s -= 25; f.append(Finding("trust","warn","T_NO_SOCIAL_PROOF","No social proof (reviews/ratings) near decision points."))
+        # price transparency: look for fee/tax mention if a price is shown
+        if _has(r'\$\d', blob) and not _has(r'(total|incl\.|including|fees?|tax|all-in)', blob):
+            s -= 20; f.append(Finding("trust","warn","T_HIDDEN_COST","Price shown without total/fees/tax transparency (shock-factor risk)."))
+        if _has(r'(create account|register).{0,40}(required|to continue)', blob) and not _has(r'guest', blob):
+            s -= 15; f.append(Finding("trust","warn","T_FORCED_ACCOUNT","Forced account with no guest option (~26% abandonment)."))
+    else:
+        # non-transactional: trust cues optional but rewarded
+        if trust_cues == 0 and not social:
+            s -= 10; f.append(Finding("trust","warn","T_LIGHT_TRUST","Consider adding credibility cues (logos, testimonials)."))
+    r.scores["trust"] = max(s, 0)
+
+    # ---------- LAW 4: Peak-End Rule ----------
+    s = 100
+    if not _has(r'transition\s*:', style):
+        s -= 30; f.append(Finding("peak","warn","P_NO_TRANSITIONS","No CSS transitions — micro-interactions create peaks of delight."))
+    if not _has(r':hover', style):
+        s -= 25; f.append(Finding("peak","warn","P_NO_HOVER","No :hover states — buttons should feel satisfying to interact with."))
+    has_form = _has(r'<form|<input', html)
+    if has_form and not (_has(r':valid|:invalid', style) or _has(r'(checkmark|✓|valid)', blob)):
+        s -= 25; f.append(Finding("peak","warn","P_NO_INLINE_VALID","Form without inline validation feedback (gentle confirmation)."))
+    r.scores["peak"] = max(s, 0)
+
+    # ---------- LAW 5: Horn-Effect Defense (consistency + mobile) ----------
+    s = 100
+    if not _has(r'@media', style):
+        s -= 40; f.append(Finding("horn","fail","C_NO_RESPONSIVE","No @media query — broken mobile is an instant unreliability signal."))
+    if not _has(r'var\(--|:root', style):
+        s -= 25; f.append(Finding("horn","warn","C_NO_CSS_VARS","No CSS variables — hard to keep Visual DNA consistent."))
+    if not _has(r'<meta[^>]*viewport', html):
+        s -= 20; f.append(Finding("horn","fail","C_NO_VIEWPORT","Missing viewport meta — mobile layout will break."))
+    font_families = set(re.findall(r'font-family\s*:\s*([^;]+)', style, re.I))
+    if len(font_families) > 3:
+        s -= 15; f.append(Finding("horn","warn","C_FONT_SOUP",f"{len(font_families)} distinct font-family declarations — inconsistency risks the Horn Effect."))
+    r.scores["horn"] = max(s, 0)
+
+    # ---------- HARD FAILS: major functional flaws (the non-negotiable warning) ----------
+    # a pretty page must never ship over a broken PRIMARY action / accessibility
+    buttons = re.findall(r'<(button|a)\b[^>]*>(.*?)</\1>', html, re.S | re.I)
+    unlabeled = [b for tag,b in buttons if not re.sub(r'<[^>]+>','',b).strip() and 'aria-label' not in b]
+    if is_transactional and unlabeled:
+        r.hard_failures.append("MAJOR_FLAW: primary action button has no accessible label/text.")
+        f.append(Finding("warning","hard_fail","X_UNLABELED_CTA","A primary action is unlabeled — major usability flaw; fix before aesthetics."))
+    imgs = re.findall(r'<img\b[^>]*>', html, re.I)
+    missing_alt = [i for i in imgs if 'alt=' not in i]
+    if len(missing_alt) >= max(3, len(imgs)//2) and imgs:
+        r.hard_failures.append(f"MAJOR_FLAW: {len(missing_alt)}/{len(imgs)} images missing alt text (accessibility).")
+        f.append(Finding("warning","hard_fail","X_NO_ALT","Widespread missing alt text — accessibility failure blocks ship."))
+    return r

prestige_design/biases.py

@@ -0,0 +1,119 @@
+"""The Cognitive Bias Engine — maps psychological triggers to concrete,
+detectable interface elements. This is the depth upgrade: instead of five
+vague 'laws', the audit checks whether specific, research-backed biases are
+actually engaged in the markup, and scores how well each is executed.
+
+Credibility judgments form in ~0.05s (Google Research); trigger-driven UX
+lifts conversion ~34% on average (Nielsen Norman 2024). Each bias below has:
+a detector (is it present?), a quality check (is it done right?), and a
+precise recommendation (how to fix it).
+"""
+from __future__ import annotations
+import re
+from dataclasses import dataclass, field
+
+@dataclass
+class BiasCheck:
+    name: str
+    present: bool
+    quality: float          # 0..1 — how well executed when present
+    weight: int             # conversion impact weight
+    recommendation: str = ""
+    evidence: str = ""
+
+def _has(p, t): return re.search(p, t, re.I) is not None
+def _count(p, t): return len(re.findall(p, t, re.I))
+
+def check_von_restorff(html: str, css: str) -> BiasCheck:
+    """Isolation effect: the CTA must visually stand out. Single, contrasting
+    primary button. Competing equal-weight CTAs KILL this (a documented mistake)."""
+    buttons = re.findall(r'<(?:button|a)[^>]*class=["\'][^"\']*(?:btn|button|cta)[^"\']*["\'][^>]*>', html, re.I)
+    primary_markers = _count(r'(btn-primary|cta-primary|primary|hero-cta)', html)
+    has_contrast = _has(r'(background|bg-)[^;]*(var\(--|#[0-9a-f]{3,6}|rgb)', css)
+    present = len(buttons) > 0 or _count(r'<button', html) > 0
+    # too many equal CTAs = failure of isolation
+    total_ctas = _count(r'<button|class=["\'][^"\']*(btn|cta)', html)
+    quality = 1.0
+    rec = ""
+    if total_ctas > 4:
+        quality = 0.4; rec = f"{total_ctas} button-like elements compete — isolate ONE primary CTA with unique color/size (Von Restorff)."
+    elif primary_markers == 0 and total_ctas > 1:
+        quality = 0.6; rec = "No distinct 'primary' CTA class — mark the single most important action so it stands out."
+    elif not has_contrast:
+        quality = 0.7; rec = "Primary CTA needs a contrasting color vs background to trigger the isolation effect."
+    return BiasCheck("Von Restorff (CTA isolation)", present, quality, 20, rec,
+                     f"{total_ctas} CTA-like elements, {primary_markers} marked primary")
+
+def check_anchoring(html: str, css: str) -> BiasCheck:
+    """Anchoring: show a higher reference price next to the actual price so the
+    real price reads as a deal. Present only relevant on pricing UIs."""
+    has_price = _has(r'[\$£€]\s?\d', html)
+    if not has_price:
+        return BiasCheck("Anchoring (price)", False, 1.0, 12, "", "no pricing shown (N/A)")
+    # look for a struck-through / original / 'was' price near the active one
+    has_anchor = (_has(r'(was|originally|reg\.|<s>|<del>|line-through|strikethrough|compare)', html) or
+                  _has(r'text-decoration\s*:\s*line-through', css))
+    quality = 1.0 if has_anchor else 0.3
+    rec = "" if has_anchor else "Pricing shown with no anchor — display an original/higher reference price (e.g. 'Was $199, now $99') so the real price reads as a deal."
+    return BiasCheck("Anchoring (price)", True, quality, 12, rec,
+                     "anchor present" if has_anchor else "no reference anchor")
+
+def check_loss_aversion(html: str) -> BiasCheck:
+    """Scarcity / urgency / FOMO: limited stock, countdowns, 'only N left'.
+    Powerful but must be genuine — flag but reward when present."""
+    is_transactional = _has(r'(buy|checkout|purchase|book|subscribe|order|add to cart)', html)
+    if not is_transactional:
+        return BiasCheck("Loss Aversion (scarcity/urgency)", False, 1.0, 10, "", "not transactional (N/A)")
+    has_scarcity = _has(r'(only \d+[\w\s]{0,15}left|limited|selling fast|\d+ (seats?|left|spots?|in stock)|ends? (in|soon)|today only|last chance|launch pricing|hurry|\d+ people (are )?viewing)', html)
+    has_urgency = _has(r'(countdown|timer|expires?|deadline|\d+:\d+:\d+)', html)
+    present = has_scarcity or has_urgency
+    quality = 1.0 if present else 0.5
+    rec = "" if present else "Transactional page with no scarcity/urgency cue — a genuine 'only N left' or time-limited signal engages loss aversion (use only if TRUE)."
+    return BiasCheck("Loss Aversion (scarcity/urgency)", present, quality, 10, rec,
+                     "scarcity/urgency present" if present else "none")
+
+def check_social_proof(html: str) -> BiasCheck:
+    """Social proof near the decision point. Best: specific numbers + near CTA."""
+    has_proof = _has(r'(review|rating|testimonial|★|⭐|\d+[\d,]*\+? (customers|users|happy|reviews)|trusted by|as seen (in|on)|join \d)', html)
+    has_specific = _has(r'\d[\d,]*\+?\s*(customers|users|reviews|companies|teams|happy)', html)
+    has_logos = _has(r'(logo|featured|as-seen|press|forbes|techcrunch|trusted-by)', html)
+    present = has_proof
+    quality = 1.0 if (has_specific and (has_proof or has_logos)) else 0.6 if present else 0.0
+    rec = ("" if quality >= 1.0 else
+           "Add specific social proof numbers ('Join 5,000+ customers') and trust logos near the CTA." if not has_specific else
+           "Social proof present — move it adjacent to the primary CTA for maximum effect.")
+    return BiasCheck("Social Proof", present, quality, 18, rec,
+                     "specific + logos" if (has_specific and has_logos) else "present" if present else "absent")
+
+def check_cognitive_fluency(html: str, css: str) -> BiasCheck:
+    """Easy-to-process = trustworthy. Whitespace, hierarchy, short blocks."""
+    has_whitespace = bool(re.search(r'padding[^;:]*:\s*([3-9]|\d{2,})(rem|vw|vh|em)', css, re.I))
+    has_hierarchy = _count(r'<h[12]', html) >= 1 and _has(r'font-size', css)
+    has_generous_leading = _has(r'line-height\s*:\s*(1\.[6-9]|[2-9])', css)
+    score = sum([has_whitespace, has_hierarchy, has_generous_leading]) / 3
+    rec = ""
+    if not has_whitespace: rec = "Increase section padding (≥6vw) — whitespace reads as premium and reduces cognitive load."
+    elif not has_generous_leading: rec = "Set body line-height ≥1.6 — easier processing reads as more trustworthy (fluency effect)."
+    return BiasCheck("Cognitive Fluency", True, score, 15, rec,
+                     f"whitespace={has_whitespace}, hierarchy={has_hierarchy}, leading={has_generous_leading}")
+
+def check_reciprocity(html: str) -> BiasCheck:
+    """Give before you ask: free trial, free guide, value upfront."""
+    has_give = _has(r'(free|trial|no (credit card|cost)|complimentary|gift|download.{0,20}free|get started free)', html)
+    is_transactional = _has(r'(buy|subscribe|sign\s*up|checkout|book)', html)
+    if not is_transactional:
+        return BiasCheck("Reciprocity", has_give, 1.0 if has_give else 0.7, 8, "", "N/A")
+    quality = 1.0 if has_give else 0.5
+    rec = "" if has_give else "Offer value before asking — a free trial/guide/'no credit card' cue triggers reciprocity and lowers signup friction."
+    return BiasCheck("Reciprocity", has_give, quality, 8, rec,
+                     "value-first present" if has_give else "asks without giving")
+
+def run_bias_suite(html: str, css: str) -> list[BiasCheck]:
+    return [
+        check_von_restorff(html, css),
+        check_social_proof(html),
+        check_cognitive_fluency(html, css),
+        check_anchoring(html, css),
+        check_loss_aversion(html),
+        check_reciprocity(html),
+    ]