@triedotdev/mcp 1.0.7 → 1.0.8

package/dist/{chunk-EDWYG3KK.js → chunk-Z3GM6UVW.js}

@@ -1203,10 +1203,10 @@ var ComprehensionAgent = class extends BaseAgent {
   }
 };
 
-// src/agents/design-engineer.ts
-var DesignEngineerAgent = class extends BaseAgent {
-  name = "design-engineer";
-  description = "WCAG 2.1 accessibility compliance, visual polish, and UX best practices";
+// src/agents/accessibility.ts
+var AccessibilityAgent = class extends BaseAgent {
+  name = "accessibility";
+  description = "WCAG 2.1 accessibility compliance, keyboard nav, screen readers, color contrast";
   version = "1.0.0";
   shouldActivate(context) {
     return context.touchesUI;
@@ -1219,7 +1219,7 @@ var DesignEngineerAgent = class extends BaseAgent {
         issues.push(...this.analyzeAccessibility(content, file));
         issues.push(...this.analyzeUXPatterns(content, file));
       } catch (error) {
-        console.error(`Design Engineer Agent: Error reading file ${file}:`, error);
+        console.error(`Accessibility Agent: Error reading file ${file}:`, error);
       }
     }
     return issues;
@@ -1350,6 +1350,408 @@ var DesignEngineerAgent = class extends BaseAgent {
   }
 };
 
+// src/agents/design-engineer.ts
+var DesignEngineerAgent = class extends BaseAgent {
+  name = "design-engineer";
+  description = "Award-winning frontend craft: design systems, motion design, creative CSS, Awwwards-level polish";
+  version = "1.0.0";
+  shouldActivate(context) {
+    return context.touchesUI;
+  }
+  async analyzeFiles(files, _context) {
+    const issues = [];
+    for (const file of files) {
+      try {
+        const content = await this.readFile(file);
+        if (this.isFrontendFile(file)) {
+          issues.push(...this.analyzeDesignSystem(content, file));
+          issues.push(...this.analyzeMotionDesign(content, file));
+          issues.push(...this.analyzeVisualCraft(content, file));
+          issues.push(...this.analyzeModernCSS(content, file));
+          issues.push(...this.analyzePerformance(content, file));
+        }
+      } catch (error) {
+        console.error(`Design Engineer Agent: Error reading file ${file}:`, error);
+      }
+    }
+    return issues;
+  }
+  isFrontendFile(file) {
+    return /\.(tsx|jsx|vue|svelte|astro|css|scss|sass|less|styled\.(ts|js))$/.test(file);
+  }
+  /**
+   * Analyze design system patterns
+   */
+  analyzeDesignSystem(content, file) {
+    const issues = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNumber = i + 1;
+      if (/margin|padding|gap|top|left|right|bottom/i.test(line)) {
+        const magicPx = line.match(/:\s*(\d+)px/);
+        if (magicPx && !["0", "1", "2"].includes(magicPx[1])) {
+          const value = parseInt(magicPx[1]);
+          const scale = [4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 80, 96, 128];
+          if (!scale.includes(value)) {
+            issues.push(this.createIssue(
+              this.generateIssueId(),
+              "low",
+              `Magic number ${value}px \u2014 consider using a spacing token`,
+              `Use a design token like --space-${Math.round(value / 4)} or spacing scale (4, 8, 12, 16, 24, 32...)`,
+              file,
+              lineNumber,
+              0.6,
+              void 0,
+              false
+            ));
+          }
+        }
+      }
+      if (/color|background|border|fill|stroke/i.test(line)) {
+        const hardcodedHex = line.match(/#[0-9a-fA-F]{3,8}(?![0-9a-fA-F])/);
+        const hardcodedRgb = line.match(/rgba?\s*\(\s*\d+/);
+        if ((hardcodedHex || hardcodedRgb) && !line.includes("var(--")) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "low",
+            "Hardcoded color value \u2014 use a design token",
+            "Define colors in CSS custom properties: var(--color-primary), var(--color-surface), etc.",
+            file,
+            lineNumber,
+            0.7,
+            void 0,
+            false
+          ));
+        }
+      }
+      if (/font-size/i.test(line)) {
+        const pxSize = line.match(/font-size:\s*(\d+)px/);
+        if (pxSize) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "low",
+            "Fixed font-size in px \u2014 consider fluid typography",
+            "Use clamp() for responsive text: font-size: clamp(1rem, 2vw + 0.5rem, 1.5rem)",
+            file,
+            lineNumber,
+            0.65,
+            void 0,
+            false
+          ));
+        }
+      }
+      if (/z-index:\s*(\d+)/.test(line)) {
+        const zValue = parseInt(line.match(/z-index:\s*(\d+)/)?.[1] || "0");
+        if (zValue > 100 && zValue !== 9999) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "moderate",
+            `High z-index (${zValue}) \u2014 establish a z-index scale`,
+            "Create z-index tokens: --z-dropdown: 100, --z-modal: 200, --z-toast: 300, --z-tooltip: 400",
+            file,
+            lineNumber,
+            0.75,
+            void 0,
+            false
+          ));
+        }
+      }
+    }
+    return issues;
+  }
+  /**
+   * Analyze motion design patterns
+   */
+  analyzeMotionDesign(content, file) {
+    const issues = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNumber = i + 1;
+      if (/transition/i.test(line) && !line.includes("cubic-bezier") && !line.includes("ease")) {
+        if (line.includes("linear") || !/ease|cubic|spring/.test(line)) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "low",
+            "Transition using linear timing \u2014 add easing for polish",
+            "Use custom easing: cubic-bezier(0.22, 1, 0.36, 1) for smooth deceleration, or ease-out for exits",
+            file,
+            lineNumber,
+            0.7,
+            void 0,
+            false
+          ));
+        }
+      }
+      if (/transition.*(\d+)ms/.test(line)) {
+        const duration = parseInt(line.match(/(\d+)ms/)?.[1] || "0");
+        if (duration > 0 && duration < 100) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "low",
+            `Very short transition (${duration}ms) \u2014 may feel jarring`,
+            "Micro-interactions work best at 150-300ms. Use 100ms minimum for perceivable motion.",
+            file,
+            lineNumber,
+            0.6,
+            void 0,
+            false
+          ));
+        }
+      }
+      if (/@keyframes|animation:/i.test(line)) {
+        if (!content.includes("prefers-reduced-motion")) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "moderate",
+            "Animation without reduced-motion fallback",
+            "Add @media (prefers-reduced-motion: reduce) { animation: none } for motion-sensitive users",
+            file,
+            lineNumber,
+            0.8,
+            void 0,
+            false
+          ));
+        }
+      }
+      if (/\.map\s*\(|v-for|ngFor|\*ngFor|{#each/.test(line)) {
+        const nextLines = lines.slice(i, i + 10).join("\n");
+        if (nextLines.includes("animation") && !nextLines.includes("delay") && !nextLines.includes("stagger")) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "low",
+            "List items animate without stagger \u2014 add animation delay",
+            "Stagger reveals with animation-delay: calc(var(--index) * 50ms) for Awwwards-level polish",
+            file,
+            lineNumber,
+            0.65,
+            void 0,
+            false
+          ));
+        }
+      }
+    }
+    return issues;
+  }
+  /**
+   * Analyze visual craft and creative techniques
+   */
+  analyzeVisualCraft(content, file) {
+    const issues = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNumber = i + 1;
+      if (/box-shadow:/i.test(line) && !line.includes(",")) {
+        issues.push(this.createIssue(
+          this.generateIssueId(),
+          "low",
+          "Single-layer box-shadow \u2014 layer shadows for depth",
+          "Use layered shadows: box-shadow: 0 1px 2px rgba(0,0,0,.1), 0 4px 12px rgba(0,0,0,.1)",
+          file,
+          lineNumber,
+          0.55,
+          void 0,
+          false
+        ));
+      }
+      if (/border-radius:\s*(\d+)px/.test(line)) {
+        const radius = parseInt(line.match(/border-radius:\s*(\d+)px/)?.[1] || "0");
+        if (radius > 0 && ![2, 4, 6, 8, 12, 16, 24, 9999].includes(radius)) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "low",
+            `Border-radius ${radius}px \u2014 use a radius scale`,
+            "Establish a radius scale: --radius-sm: 4px, --radius-md: 8px, --radius-lg: 16px, --radius-full: 9999px",
+            file,
+            lineNumber,
+            0.5,
+            void 0,
+            false
+          ));
+        }
+      }
+      if (/hero|banner|header|jumbotron/i.test(file) || /Hero|Banner|Header/i.test(content.slice(0, 500))) {
+        if (/background:\s*#|background-color:/i.test(line) && !line.includes("gradient")) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "low",
+            "Solid background in hero section \u2014 consider a subtle gradient",
+            "Add depth with gradients: background: linear-gradient(135deg, var(--color-bg) 0%, var(--color-surface) 100%)",
+            file,
+            lineNumber,
+            0.5,
+            void 0,
+            false
+          ));
+        }
+      }
+      if (/overlay|modal|dialog|drawer/i.test(line) || /position:\s*fixed/.test(line)) {
+        const context = lines.slice(Math.max(0, i - 5), i + 10).join("\n");
+        if (!context.includes("backdrop") && context.includes("background")) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "low",
+            "Overlay without backdrop blur \u2014 add glassmorphism effect",
+            "Use backdrop-filter: blur(12px) with semi-transparent background for modern glass effect",
+            file,
+            lineNumber,
+            0.55,
+            void 0,
+            false
+          ));
+        }
+      }
+    }
+    return issues;
+  }
+  /**
+   * Analyze modern CSS feature usage
+   */
+  analyzeModernCSS(content, file) {
+    const issues = [];
+    if (/@media.*width/.test(content) && !content.includes("container-type")) {
+      issues.push(this.createIssue(
+        this.generateIssueId(),
+        "low",
+        "Using media queries \u2014 consider container queries for component isolation",
+        "Use container queries for truly reusable components: container-type: inline-size; @container (min-width: 400px) {...}",
+        file,
+        void 0,
+        0.5,
+        void 0,
+        false
+      ));
+    }
+    if (content.includes("padding") && content.includes("max-width") && !content.includes("clamp(")) {
+      issues.push(this.createIssue(
+        this.generateIssueId(),
+        "low",
+        "Consider fluid spacing with clamp()",
+        "Use clamp() for responsive spacing: padding: clamp(1rem, 5vw, 3rem)",
+        file,
+        void 0,
+        0.45,
+        void 0,
+        false
+      ));
+    }
+    if (/\.parent.*\.child|parentElement|closest\(/i.test(content)) {
+      issues.push(this.createIssue(
+        this.generateIssueId(),
+        "low",
+        "JavaScript parent selection \u2014 consider CSS :has()",
+        "Use CSS :has() for parent styling: .card:has(.featured) { border: 2px solid gold }",
+        file,
+        void 0,
+        0.55,
+        void 0,
+        false
+      ));
+    }
+    if (/grid-template-columns:\s*repeat\(\d+,/.test(content) && !content.includes("auto-fit") && !content.includes("auto-fill")) {
+      issues.push(this.createIssue(
+        this.generateIssueId(),
+        "low",
+        "Fixed grid columns \u2014 use auto-fit for responsive grids",
+        "Use intrinsic sizing: grid-template-columns: repeat(auto-fit, minmax(min(300px, 100%), 1fr))",
+        file,
+        void 0,
+        0.6,
+        void 0,
+        false
+      ));
+    }
+    if (/padding-top:\s*\d+%|padding-bottom:\s*\d+%/.test(content) && !content.includes("aspect-ratio")) {
+      issues.push(this.createIssue(
+        this.generateIssueId(),
+        "moderate",
+        "Padding-based aspect ratio hack \u2014 use aspect-ratio property",
+        "Use native aspect-ratio: aspect-ratio: 16 / 9 instead of padding hacks",
+        file,
+        void 0,
+        0.8,
+        void 0,
+        true
+      ));
+    }
+    return issues;
+  }
+  /**
+   * Analyze animation performance
+   */
+  analyzePerformance(content, file) {
+    const issues = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNumber = i + 1;
+      if (/transition|animation/i.test(line)) {
+        if (/width|height|top|left|right|bottom|margin|padding/i.test(line) && !line.includes("transform") && !line.includes("opacity")) {
+          issues.push(this.createIssue(
+            this.generateIssueId(),
+            "moderate",
+            "Animating layout properties \u2014 use transform instead",
+            "Animate transform/opacity for 60fps. Replace top/left with translate, width/height with scale",
+            file,
+            lineNumber,
+            0.85,
+            void 0,
+            false
+          ));
+        }
+      }
+      if (/will-change:\s*transform|will-change:\s*opacity/.test(line)) {
+        issues.push(this.createIssue(
+          this.generateIssueId(),
+          "low",
+          "Static will-change \u2014 apply dynamically",
+          "Add will-change on hover/focus, remove after animation. Permanent will-change wastes GPU memory.",
+          file,
+          lineNumber,
+          0.7,
+          void 0,
+          false
+        ));
+      }
+      if (/transition.*filter|animation.*filter|filter.*transition/i.test(line)) {
+        issues.push(this.createIssue(
+          this.generateIssueId(),
+          "moderate",
+          "Animating filter is expensive \u2014 use sparingly",
+          "Filter animations trigger repaint. Consider opacity/transform alternatives or accept lower framerates.",
+          file,
+          lineNumber,
+          0.75,
+          void 0,
+          false
+        ));
+      }
+      if (/transition.*box-shadow|animation.*box-shadow|box-shadow.*transition/i.test(line)) {
+        const context = lines.slice(Math.max(0, i - 3), i + 3).join("\n");
+        if (/blur\s*\(\s*(\d+)/.test(context)) {
+          const blur = parseInt(context.match(/blur\s*\(\s*(\d+)/)?.[1] || "0");
+          if (blur > 20) {
+            issues.push(this.createIssue(
+              this.generateIssueId(),
+              "moderate",
+              `Large shadow blur (${blur}px) in animation \u2014 may drop frames`,
+              "Use pseudo-element for shadow animation: animate opacity of ::after with the shadow instead",
+              file,
+              lineNumber,
+              0.7,
+              void 0,
+              false
+            ));
+          }
+        }
+      }
+    }
+    return issues;
+  }
+};
+
 // src/agents/legal.ts
 var LegalAgent = class extends BaseAgent {
   name = "legal";
@@ -2187,7 +2589,7 @@ var UserTestingAgent = class extends BaseAgent {
       name: this.name,
       tier: 2,
       estimatedTimeMs: 150,
-      dependencies: ["design-engineer"]
+      dependencies: ["accessibility"]
       // accessibility before UX
     };
   }
@@ -2907,6 +3309,157 @@ var SOC2Agent = class extends BaseAgent {
   }
 };
 
+// src/agents/super-reviewer.ts
+var SuperReviewerAgent = class extends BaseAgent {
+  name = "super-reviewer";
+  description = "Interactive PR review: walks through changes file-by-file, explains each chunk, waits for cross-examination";
+  version = "1.0.0";
+  shouldActivate(context) {
+    return context.linesChanged > 50 || context.isNewFeature || context.touchesAuth || context.touchesPayment || context.touchesDatabase || context.touchesAPI;
+  }
+  /**
+   * The Super Reviewer doesn't do static pattern matching like other agents.
+   * Instead, it generates a structured review workflow for the AI to execute.
+   */
+  async analyzeFiles(files, context) {
+    return [];
+  }
+  /**
+   * Get the structured review workflow for a set of files/changes
+   */
+  async buildReviewWorkflow(changedFiles, options) {
+    const orderedFiles = this.orderFilesForReview(changedFiles);
+    return {
+      metadata: {
+        prNumber: options.prNumber,
+        prTitle: options.prTitle,
+        prAuthor: options.prAuthor,
+        baseBranch: options.baseBranch,
+        headBranch: options.headBranch,
+        mode: options.mode || "own",
+        totalFiles: changedFiles.length,
+        totalAdditions: changedFiles.reduce((sum, f) => sum + f.additions, 0),
+        totalDeletions: changedFiles.reduce((sum, f) => sum + f.deletions, 0)
+      },
+      fileOrder: orderedFiles.map((f, idx) => ({
+        index: idx + 1,
+        path: f.path,
+        reason: f.orderReason,
+        additions: f.additions,
+        deletions: f.deletions
+      })),
+      designDocs: options.designDocs || [],
+      reviewInstructions: this.getReviewInstructions(options.mode || "own")
+    };
+  }
+  /**
+   * Order files for understanding, not alphabetically
+   * 
+   * Strategy:
+   * 1. Protos/schemas first — define data structures
+   * 2. Constants/configs early — context for magic values
+   * 3. Core logic before utilities — understand main change before helpers
+   * 4. Implementation before tests — know what's being tested
+   * 5. Docs/comments last — reference during review
+   */
+  orderFilesForReview(files) {
+    const scored = files.map((file) => {
+      let priority = 50;
+      let reason = "General implementation";
+      const path = file.path.toLowerCase();
+      const filename = path.split("/").pop() || "";
+      if (/\.(proto|graphql|prisma)$/.test(path) || /schema\.(ts|js|json)$/.test(path) || /types?\.(ts|d\.ts)$/.test(path) || path.includes("/types/") || path.includes("/schema/")) {
+        priority = 10;
+        reason = "Defines data structures everything else uses";
+      } else if (/constants?\.(ts|js)$/.test(path) || /config\.(ts|js|json)$/.test(path) || path.includes("/config/") || /\.env/.test(path)) {
+        priority = 20;
+        reason = "Gives context for values used throughout";
+      } else if (path.includes("/core/") || path.includes("/services/") || path.includes("/domain/") || path.includes("/lib/")) {
+        priority = 30;
+        reason = "Core logic \u2014 understand this first";
+      } else if (path.includes("/api/") || path.includes("/routes/") || path.includes("/handlers/") || path.includes("/controllers/")) {
+        priority = 40;
+        reason = "API layer \u2014 connects core logic to consumers";
+      } else if (path.includes("/components/") || path.includes("/pages/") || path.includes("/views/") || /\.(tsx|jsx|vue|svelte)$/.test(path)) {
+        priority = 50;
+        reason = "UI layer \u2014 uses core logic and types";
+      } else if (path.includes("/utils/") || path.includes("/helpers/") || /utils?\.(ts|js)$/.test(path)) {
+        priority = 60;
+        reason = "Helper utilities";
+      } else if (/\.(test|spec)\.(ts|js|tsx|jsx)$/.test(path) || path.includes("__tests__") || path.includes("/test/")) {
+        priority = 70;
+        reason = "Tests \u2014 review after understanding the implementation";
+      } else if (/\.(md|mdx|txt)$/.test(path) || /readme/i.test(path) || path.includes("/docs/")) {
+        priority = 80;
+        reason = "Documentation \u2014 reference during review as needed";
+      } else if (/package\.json$/.test(path) || /tsconfig/.test(path) || /\.config\.(ts|js|json)$/.test(path)) {
+        priority = 90;
+        reason = "Project config \u2014 review last";
+      }
+      return { ...file, priority, orderReason: reason };
+    });
+    return scored.sort((a, b) => a.priority - b.priority);
+  }
+  /**
+   * Get the review mode instructions
+   */
+  getReviewInstructions(mode) {
+    if (mode === "own") {
+      return {
+        mode: "own",
+        description: "Your own PR \u2014 I explain, you learn/verify/fix",
+        approach: [
+          "Walk through each file explaining what changed and why",
+          "Help you understand your own code better",
+          "Identify potential issues before reviewers do",
+          "Suggest improvements you can make before requesting review"
+        ],
+        afterEachFile: [
+          "Pause for your questions",
+          "Discuss any concerns you have",
+          "Note any self-review fixes to make"
+        ]
+      };
+    } else {
+      return {
+        mode: "others",
+        description: "Someone else's PR \u2014 I flag issues, you add comments",
+        approach: [
+          "Analyze each file for correctness and completeness",
+          "Flag potential issues with suggested comment text",
+          "Look for missing pieces (cleanup handlers, tests, edge cases)",
+          "Check state/lifecycle consistency"
+        ],
+        afterEachFile: [
+          "Present draft comments for your approval",
+          "Let you modify or skip each comment",
+          "Post approved comments to PR"
+        ]
+      };
+    }
+  }
+};
+var CRITICAL_REVIEW_CHECKLIST = {
+  stateAndLifecycle: [
+    "Cleanup symmetry: If state is set, is it reset? Check cleanup paths.",
+    "Lifecycle consistency: Does state survive scenarios it shouldn't?",
+    "Guard completeness: Are there missing guards (already active, re-entrancy)?"
+  ],
+  edgeCasesAndRaces: [
+    "Concurrent calls: What if called twice rapidly? Orphaned promises?",
+    "Ordering assumptions: Does code assume events arrive in order?",
+    "Partial failures: If step 3 of 5 fails, is state left consistent?"
+  ],
+  missingPieces: [
+    "What's NOT in the diff that should be? (cleanup handlers, tests)",
+    "Defensive gaps: Missing timeouts, size limits, null checks?"
+  ],
+  designQuestions: [
+    "Is this the right approach? Is there a simpler/more robust design?",
+    "Hidden assumptions: What does this assume about its environment?"
+  ]
+};
+
 // src/agents/custom-agent.ts
 var CustomAgent = class extends BaseAgent {
   name;
@@ -3134,6 +3687,7 @@ var AgentRegistryImpl = class {
       new TypeCheckAgent(),
       new ComprehensionAgent(),
       // Specialized agents
+      new AccessibilityAgent(),
       new DesignEngineerAgent(),
       new LegalAgent(),
       new TestAgent(),
@@ -3142,7 +3696,8 @@ var AgentRegistryImpl = class {
       new BugFindingAgent(),
       new UserTestingAgent(),
       new TrieCleanAgent(),
-      new SOC2Agent()
+      new SOC2Agent(),
+      new SuperReviewerAgent()
     ];
     console.error(`Loaded config for ${builtinAgents.length} built-in agents`);
     for (const agent of builtinAgents) {
@@ -4068,7 +4623,7 @@ var Triager = class {
         reasons.push("CAN-SPAM");
       }
     }
-    if (agent.name === "design-engineer") {
+    if (agent.name === "accessibility") {
       tier = 2;
       if (context.touchesUI) {
         confidence += 0.6;
@@ -4272,7 +4827,7 @@ var Triager = class {
       // legal should see privacy issues first
       "test": ["bug-finding"],
       // find bugs before writing tests
-      "user-testing": ["design-engineer"]
+      "user-testing": ["accessibility"]
       // accessibility before UX
     };
     for (const agent of agents) {
@@ -6712,7 +7267,7 @@ var TrieScanTool = class {
       "typecheck": "always runs - type safety is fundamental",
       "comprehension": "always runs - explains changes to stakeholders",
       "legal": context.touchesHealthData ? "HIPAA compliance required" : context.touchesPayments ? "payment regulations apply" : context.touchesUserData ? "data protection laws apply" : "legal patterns detected",
-      "design-engineer": context.touchesUI ? "UI components detected" : "UI patterns detected",
+      "accessibility": context.touchesUI ? "UI components detected" : "UI patterns detected",
       "test": context.isNewFeature ? "new feature needs tests" : context.touchesAuth ? "auth code needs tests" : "test coverage needed",
       "software-architect": context.isNewFeature ? "architecture review for new feature" : context.touchesDatabase ? "database schema review" : "architecture patterns detected",
       "devops": context.touchesSecurityConfig ? "security config detected" : context.touchesDatabase ? "infrastructure changes" : "deployment patterns detected",
@@ -7105,6 +7660,72 @@ Identify:
 4. Risk assessment (litigation, fines, etc.)
 5. Remediation recommendations
 6. Required documentation/policies`
+  },
+  "design-engineer": {
+    system: `You are an elite design engineer \u2014 the kind who builds award-winning interfaces featured on Awwwards and Codrops.
+
+You think in design systems, breathe motion design, and obsess over the details that make interfaces feel magical.
+
+Your expertise:
+- **Design Systems**: Spacing scales, type scales, color tokens, radius tokens, shadow tokens
+- **Motion Design**: Micro-interactions, page transitions, scroll-triggered animations, FLIP technique
+- **Creative CSS**: Gradients, blend modes, clip-paths, masks, backdrop-filter, mix-blend-mode
+- **Modern CSS**: Container queries, :has(), subgrid, anchor positioning, cascade layers, @scope
+- **Fluid Design**: clamp(), min(), max(), fluid typography, intrinsic sizing
+- **Performance**: GPU-accelerated animations, will-change strategy, avoiding layout thrashing
+- **Visual Polish**: Layered shadows, subtle gradients, glass effects, smooth easing curves
+
+You review code with the eye of someone who's shipped Stripe-level interfaces.
+Small details matter: the easing curve, the stagger timing, the shadow layering.`,
+    analysis: `## Design Engineering Review
+
+Analyze this frontend code for Awwwards-level craft:
+
+\`\`\`{{language}}
+{{code}}
+\`\`\`
+
+**File:** {{filePath}}
+
+Review for:
+
+### 1. Design System Consistency
+- Are spacing values on a scale (4, 8, 12, 16, 24, 32...)?
+- Are colors defined as tokens?
+- Is typography systematic?
+- Are radii consistent?
+- Is z-index controlled?
+
+### 2. Motion Design
+- Are transitions using custom easing (cubic-bezier)?
+- Are durations appropriate (150-300ms for micro, 300-500ms for page)?
+- Are list items staggered?
+- Is there reduced-motion support?
+- Are entrance animations choreographed?
+
+### 3. Visual Craft
+- Are shadows layered for depth?
+- Are gradients subtle and purposeful?
+- Is there backdrop-blur on overlays?
+- Are hover states polished?
+- Is there visual hierarchy?
+
+### 4. Modern CSS Opportunities
+- Could container queries improve component isolation?
+- Could clamp() create fluid spacing?
+- Could :has() simplify parent styling?
+- Could aspect-ratio replace padding hacks?
+
+### 5. Performance
+- Are expensive properties (width, height, top, left) being animated?
+- Is will-change used appropriately (not statically)?
+- Are large blurs avoided in animations?
+
+For each issue, provide:
+- What's wrong (with specific line if applicable)
+- Why it matters for premium feel
+- Exact code to fix it
+- Before/after comparison`
   },
   accessibility: {
     system: `You are an accessibility expert and WCAG 2.1 specialist.
@@ -7402,6 +8023,130 @@ Provide:
 2. Brief explanation of the change
 3. Any related changes needed elsewhere
 4. Test to verify the fix works`
+  },
+  pr_review: {
+    system: `You are an expert code reviewer performing detailed, interactive PR reviews.
+Your goal: Make reviewing a large PR a delight, not a chore. The user learns about the change while you shepherd them through \u2014 maintaining momentum, explaining each piece, and making what could be an overwhelming task feel painless and even enjoyable.
+
+You drive; they cross-examine.
+
+## Critical Review Mindset
+
+Don't just explain \u2014 actively look for problems:
+
+### State & Lifecycle
+- Cleanup symmetry: If state is set, is it reset? Check cleanup paths, disconnect handlers.
+- Lifecycle consistency: Does state survive scenarios it shouldn't?
+- Guard completeness: Missing "already active" checks, re-entrancy protection?
+
+### Edge Cases & Races
+- Concurrent calls: What if called twice rapidly? Orphaned promises?
+- Ordering assumptions: Does code assume events arrive in order?
+- Partial failures: If step 3 of 5 fails, is state left consistent?
+
+### Missing Pieces
+- What's NOT in the diff that should be? (cleanup handlers, tests, related state)
+- Defensive gaps: Missing timeouts, size limits, null checks?
+
+### Design Questions
+- Is this the right approach? Is there a simpler or more robust design?
+- Hidden assumptions: What does this assume about its environment?
+
+Be critical, not just descriptive. Your job is to find problems, not just narrate.`,
+    analysis: `## Interactive PR Review
+
+I'll walk you through this PR file by file, explaining each change and pausing for your questions.
+
+**PR:** {{prTitle}}
+**Author:** {{prAuthor}}
+**Scope:** {{totalFiles}} files, +{{additions}}/-{{deletions}} lines
+
+### File Order (sequenced for understanding)
+
+{{fileOrder}}
+
+---
+
+## Review Mode
+
+{{reviewMode}}
+
+---
+
+For each file, I will:
+1. **Show the change** \u2014 Display the diff for each logical chunk
+2. **Explain what changed** \u2014 What it does and why it matters
+3. **Walk through examples** \u2014 Concrete scenarios for non-obvious logic
+4. **Call out nuances** \u2014 Alternatives, edge cases, subtle points
+5. **Summarize** \u2014 Core change + correctness assessment
+6. **Pause** \u2014 Wait for your questions before proceeding
+
+**Ready for File 1?** (yes / skip to [file] / reorder / done)`,
+    file: `## File Review: {{filePath}}
+
+### The Change
+
+\`\`\`{{language}}
+{{diff}}
+\`\`\`
+
+**What Changed:** {{summary}}
+
+**Why This Matters:** {{impact}}
+
+{{#if hasExampleScenario}}
+### Example Scenario
+
+{{exampleScenario}}
+{{/if}}
+
+{{#if nuances}}
+### Nuances to Note
+
+{{nuances}}
+{{/if}}
+
+{{#if potentialIssue}}
+### \u26A0\uFE0F Potential Issue
+
+**Issue:** {{issueDescription}}
+**Scenario:** {{issueScenario}}
+**Suggested fix:** {{suggestedFix}}
+{{/if}}
+
+---
+
+### Summary for \`{{fileName}}\`
+
+| Aspect | Assessment |
+|--------|------------|
+| Core change | {{coreChange}} |
+| Correctness | {{correctnessAssessment}} |
+
+**Ready for the next file?** (yes / questions? / done)`,
+    comment: `**Issue:** {{issueDescription}}
+**Draft comment:** {{draftComment}}
+
+Post this comment? (yes / modify / skip)`,
+    final: `## Review Complete
+
+| File | Key Change | Status |
+|------|------------|--------|
+{{fileSummaries}}
+
+**Overall:** {{overallAssessment}}
+
+{{#if comments}}
+### Comments Posted
+
+{{postedComments}}
+{{/if}}
+
+{{#if followUps}}
+### Follow-up Actions
+
+{{followUps}}
+{{/if}}`
   },
   vibe: {
     system: `You are a friendly coding mentor helping someone who's learning to code with AI.
@@ -7797,10 +8542,12 @@ The AI will analyze each issue, generate the fix, and you can review before appl
 };
 
 export {
+  SuperReviewerAgent,
+  CRITICAL_REVIEW_CHECKLIST,
   getAgentRegistry,
   TrieScanTool,
   getPrompt,
   getSystemPrompt,
   TrieFixTool
 };
-//# sourceMappingURL=chunk-EDWYG3KK.js.map
+//# sourceMappingURL=chunk-Z3GM6UVW.js.map