@tritard/waterbrother 0.8.33 → 0.8.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.8.33",
+  "version": "0.8.35",
   "description": "Waterbrother: Grok-powered coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -14,7 +14,21 @@ import { expandHomePath } from "./path-utils.js";
 import { AUTONOMY_MODES, buildOperatorIdentity, EXPERIENCE_MODES, modeDefaults, normalizeAutonomyMode, normalizeExperienceMode } from "./modes.js";
 import { computeImpactMap } from "./impact.js";
 import { reviewTurn } from "./reviewer.js";
-import { buildFrontendExecutionContext, reviewFrontendTurn, shouldRunFrontendReview } from "./frontend.js";
+import {
+  buildFrontendExecutionContext,
+  buildFrontendRebuildPrompt,
+  buildFrontendRevisionPrompt,
+  captureFrontendScreenshot,
+  detectFrontendSlop,
+  findFrontendPreviewEntry,
+  inspectFrontendArtifacts,
+  mergeFrontendSlop,
+  reviewFrontendTurn,
+  reviewFrontendScreenshot,
+  shouldAutoReviseFrontend,
+  shouldForceFrontendRebuild,
+  shouldRunFrontendReview
+} from "./frontend.js";
 import { loadTask, saveTask, listTasks, setActiveTask, getActiveTask, closeTask } from "./task-store.js";
 import { runDecisionPass, runInventPass, formatDecisionForDisplay, formatDecisionCompact, formatDecisionDetail } from "./decider.js";
 import { runBuildWorkflow, startFeatureTask, runChallengeWorkflow } from "./workflow.js";
@@ -1037,6 +1051,273 @@ async function enrichTurnArtifacts({ agent, context, promptText, assistantText,
   return receipt;
 }
 
+async function analyzeTurnArtifacts({
+  agent,
+  context,
+  promptText,
+  assistantText,
+  receipt,
+  frontend = null,
+  signal
+}) {
+  let impact = receipt.impact || null;
+  if (receipt.mutated && context.runtime.impact?.enabled !== false) {
+    impact = await computeImpactMap({
+      cwd: context.cwd,
+      changedFiles: receipt.changedFiles || [],
+      maxRelated: context.runtime.impact?.maxRelated,
+      maxTests: context.runtime.impact?.maxTests
+    });
+  }
+
+  let review = receipt.review || null;
+  if (receipt.mutated && context.runtime.reviewer?.enabled !== false) {
+    try {
+      review = await reviewTurn({
+        apiKey: context.runtime.apiKey,
+        baseUrl: context.runtime.baseUrl,
+        model: context.runtime.reviewer?.model || agent.getModel(),
+        promptText,
+        assistantText,
+        receipt: { ...receipt, diff: receipt.diff || "" },
+        impact,
+        maxDiffChars: context.runtime.reviewer?.maxDiffChars,
+        signal
+      });
+    } catch (error) {
+      review = {
+        verdict: "caution",
+        summary: `review failed: ${error instanceof Error ? error.message : String(error)}`,
+        concerns: ["Sentinel reviewer could not complete."],
+        followups: []
+      };
+    }
+  }
+
+  let designReview = receipt.designReview || null;
+  if (shouldRunFrontendReview({ promptText, receipt, profile: agent.getProfile() })) {
+    try {
+      designReview = await reviewFrontendTurn({
+        apiKey: context.runtime.apiKey,
+        baseUrl: context.runtime.baseUrl,
+        model: context.runtime.reviewer?.model || agent.getModel(),
+        promptText,
+        assistantText,
+        receipt: { ...receipt, diff: receipt.diff || "" },
+        signal
+      });
+    } catch (error) {
+      designReview = {
+        verdict: "caution",
+        summary: `design review failed: ${error instanceof Error ? error.message : String(error)}`,
+        strengths: [],
+        issues: ["Frontend design reviewer could not complete."],
+        nextPass: []
+      };
+    }
+  }
+
+  let screenshotReview = null;
+  let screenshotPath = null;
+  if (designReview) {
+    try {
+      const previewEntry = await findFrontendPreviewEntry({ cwd: context.cwd, receipt });
+      if (previewEntry) {
+        screenshotPath = await captureFrontendScreenshot({ entryPath: previewEntry });
+        if (screenshotPath) {
+          screenshotReview = await reviewFrontendScreenshot({
+            apiKey: context.runtime.apiKey,
+            baseUrl: context.runtime.baseUrl,
+            model: context.runtime.reviewer?.model || agent.getModel(),
+            screenshotPath,
+            promptText,
+            signal
+          });
+        }
+      }
+    } catch {
+      screenshotReview = null;
+    }
+  }
+
+  const deterministicSlop = designReview
+    ? detectFrontendSlop({ promptText, assistantText, receipt, designReview })
+    : null;
+  const artifactSlop = designReview
+    ? await inspectFrontendArtifacts({ cwd: context.cwd, receipt, frontend })
+    : null;
+  const designSlop = mergeFrontendSlop(deterministicSlop, artifactSlop);
+
+  return {
+    impact,
+    review,
+    designReview,
+    designSlop,
+    screenshotReview,
+    screenshotPath
+  };
+}
+
+async function finalizeReceiptArtifacts({
+  agent,
+  context,
+  receipt,
+  artifacts,
+  signal
+}) {
+  if (!receipt) return null;
+  const updates = {};
+  if (artifacts?.impact) updates.impact = artifacts.impact;
+  if (artifacts?.review) updates.review = artifacts.review;
+  if (artifacts?.designReview) updates.designReview = artifacts.designReview;
+  if (artifacts?.designSlop) updates.designSlop = artifacts.designSlop;
+  if (artifacts?.screenshotReview) updates.screenshotReview = artifacts.screenshotReview;
+  if (artifacts?.screenshotPath) updates.screenshotPath = artifacts.screenshotPath;
+  if (artifacts?.designRevision) updates.designRevision = artifacts.designRevision;
+  const finalReceipt = Object.keys(updates).length > 0
+    ? (await agent.toolRuntime.updateReceipt(receipt.id, updates) || receipt)
+    : receipt;
+  context.runtime.lastReceipt = finalReceipt;
+  context.runtime.lastImpact = artifacts?.impact || finalReceipt.impact || null;
+  return finalReceipt;
+}
+
+async function maybeReviseInteractiveFrontend({
+  agent,
+  context,
+  promptText,
+  response,
+  receipt,
+  frontendExecutionContext = null,
+  previousExecutionContext = null,
+  signal
+}) {
+  if (!frontendExecutionContext || !receipt) {
+    return { response, receipt, artifacts: null };
+  }
+
+  const baseExecutionContext = { ...(previousExecutionContext || {}), ...frontendExecutionContext };
+  if (previousExecutionContext?.reminders && frontendExecutionContext.reminders) {
+    baseExecutionContext.reminders = `${previousExecutionContext.reminders}\n${frontendExecutionContext.reminders}`;
+  }
+
+  let activeResponse = response;
+  let activeReceipt = receipt;
+  let artifacts = await analyzeTurnArtifacts({
+    agent,
+    context,
+    promptText,
+    assistantText: activeResponse.content || "",
+    receipt: activeReceipt,
+    frontend: frontendExecutionContext.frontend || null,
+    signal
+  });
+
+  let revisionCount = 0;
+  const revisionHistory = [];
+
+  while (shouldAutoReviseFrontend({
+    designReview: artifacts.designReview,
+    slop: artifacts.designSlop,
+    revisionCount
+  })) {
+    const passNumber = revisionCount + 1;
+    const forceRebuild = shouldForceFrontendRebuild({
+      frontend: frontendExecutionContext.frontend || null,
+      slop: artifacts.designSlop,
+      revisionCount
+    });
+    revisionHistory.push({
+      passNumber,
+      verdict: artifacts.designReview?.verdict || null,
+      summary: String(artifacts.designReview?.summary || "").trim(),
+      slopFlags: Array.isArray(artifacts.designSlop?.flags) ? [...artifacts.designSlop.flags] : [],
+      mode: forceRebuild ? "rebuild" : "revise"
+    });
+    const revisionPrompt = forceRebuild
+      ? buildFrontendRebuildPrompt({
+        originalPrompt: promptText,
+        frontend: frontendExecutionContext.frontend || null,
+        designReview: artifacts.designReview,
+        slop: artifacts.designSlop,
+        screenshotReview: artifacts.screenshotReview
+      })
+      : buildFrontendRevisionPrompt({
+        originalPrompt: promptText,
+        designReview: artifacts.designReview,
+        slop: artifacts.designSlop,
+        screenshotReview: artifacts.screenshotReview
+      });
+
+    const revisionSpinner = createProgressSpinner(
+      forceRebuild ? `rebuilding frontend (${passNumber})...` : `revising frontend (${passNumber})...`
+    );
+    printLiveTrace(
+      forceRebuild ? `frontend rebuild pass ${passNumber}` : `frontend revision pass ${passNumber}`,
+      context.runtime.traceMode
+    );
+    if (activeReceipt.contract) {
+      agent.toolRuntime.setCurrentContract(activeReceipt.contract);
+    }
+    agent.setExecutionContext({
+      ...baseExecutionContext,
+      phase: forceRebuild ? `design-rebuild-${passNumber}` : `design-revision-${passNumber}`,
+      reminders: [
+        baseExecutionContext.reminders || "",
+        forceRebuild
+          ? `Automatic rebuild pass ${passNumber}: discard the previous frontend direction and rebuild within the same contract using the benchmark starter skeleton.`
+          : passNumber === 1
+            ? "Automatic second pass: fix the flagged frontend design issues without widening scope."
+            : `Automatic follow-up pass ${passNumber}: remove any remaining benchmark hard-fail patterns.`
+      ].filter(Boolean).join("\n")
+    });
+    try {
+      activeResponse = await agent.runTurn(revisionPrompt, {
+        signal,
+        onStateChange(state) {
+          printLiveTrace(`state=${state}`, context.runtime.traceMode, { verboseOnly: true });
+        },
+        onToolStart(toolCall) {
+          const toolName = toolCall?.function?.name || "tool";
+          printLiveTrace(`using ${toolName}`, context.runtime.traceMode);
+        },
+        onToolEnd(toolCall, result) {
+          const toolName = toolCall?.function?.name || "tool";
+          const status = parseToolResultShape(result);
+          const label =
+            status === "ok" ? `${toolName} ok` : status === "blocked" ? `${toolName} blocked` : `${toolName} ${status}`;
+          printLiveTrace(label, context.runtime.traceMode);
+        }
+      });
+      activeReceipt = await agent.toolRuntime.completeTurn({ signal });
+      if (!activeReceipt) break;
+      artifacts = await analyzeTurnArtifacts({
+        agent,
+        context,
+        promptText,
+        assistantText: activeResponse.content || "",
+        receipt: activeReceipt,
+        frontend: frontendExecutionContext.frontend || null,
+        signal
+      });
+      revisionCount += 1;
+    } finally {
+      revisionSpinner.stop();
+      agent.setExecutionContext(previousExecutionContext);
+    }
+  }
+
+  if (revisionCount > 0) {
+    artifacts.designRevision = {
+      triggered: true,
+      passes: revisionCount,
+      history: revisionHistory
+    };
+  }
+
+  return { response: activeResponse, receipt: activeReceipt, artifacts };
+}
+
 function describeOperator(runtime, agent) {
   const identity = buildOperatorIdentity({
     mode: agent.getExperienceMode(),
@@ -3654,18 +3935,48 @@ async function runTextTurnInteractive({
       precomputedReceipt = candidateReceipt;
     }
   }
+  let finalizedArtifacts = null;
+  let finalizedReceipt = precomputedReceipt || await agent.toolRuntime.completeTurn({ signal: abortController?.signal });
+  if (frontendExecutionContext && finalizedReceipt) {
+    const revisedFrontendTurn = await maybeReviseInteractiveFrontend({
+      agent,
+      context,
+      promptText: effectivePromptText,
+      response,
+      receipt: finalizedReceipt,
+      frontendExecutionContext,
+      previousExecutionContext,
+      signal: abortController?.signal
+    });
+    response = revisedFrontendTurn.response || response;
+    renderedAssistantText = response.content || renderedAssistantText;
+    finalizedReceipt = revisedFrontendTurn.receipt || finalizedReceipt;
+    finalizedArtifacts = revisedFrontendTurn.artifacts || null;
+  }
+
   printAssistantOutput(renderedAssistantText);
   await setSessionRunState(currentSession, agent, "done");
   printTurnSummary(turnSummary, response, { modelId: agent.getModel(), costTracker: context.costTracker, traceMode: context.runtime.traceMode });
   printTraceTimeline(turnSummary, context.runtime.traceMode);
-  const receipt = await enrichTurnArtifacts({
-    agent,
-    context,
-    promptText: effectivePromptText,
-    assistantText: response.content || '',
-    signal: abortController?.signal
-  });
-  const finalReceipt = receipt || precomputedReceipt;
+  let finalReceipt = null;
+  if (finalizedReceipt && finalizedArtifacts) {
+    finalReceipt = await finalizeReceiptArtifacts({
+      agent,
+      context,
+      receipt: finalizedReceipt,
+      artifacts: finalizedArtifacts,
+      signal: abortController?.signal
+    });
+  } else {
+    const receipt = await enrichTurnArtifacts({
+      agent,
+      context,
+      promptText: effectivePromptText,
+      assistantText: response.content || "",
+      signal: abortController?.signal
+    });
+    finalReceipt = receipt || finalizedReceipt;
+  }
   if (finalReceipt) {
     currentSession.lastReceiptId = finalReceipt.id;
     if (shouldPrintReceiptSummary(finalReceipt, context.runtime.receiptMode)) {

package/src/frontend.js

@@ -47,7 +47,7 @@ Rules:
 - Be concrete about visible layout, spacing, typography, contrast, composition, and interaction cues.
 - Do not wrap JSON in markdown.`;
 
-const BENCHMARK_FRONTEND_PROMPT = /\b(?:benchmark|squarespace quality|ultimate design|first class|on par|codex|claude code|cc)\b/i;
+const BENCHMARK_FRONTEND_PROMPT = /\b(?:benchmark|squarespace quality|ultimate design|first class|on par|codex|claude code|cc|winning shopify|winning ecommerce|high-converting|flagship pdp)\b/i;
 
 const UNIVERSAL_FRONTEND_REMINDERS = [
   "Choose one visual direction and stay consistent across typography, spacing, color, and motion.",
@@ -63,7 +63,8 @@ const BENCHMARK_FRONTEND_REMINDERS = [
   "For benchmark frontend tasks, cut generic reflective-editorial copy. Use sharper, more concrete language or neutral structural placeholders instead of atmosphere-writing.",
   "For benchmark frontend tasks, force at least one asymmetrical or compositionally distinctive move instead of a fully balanced template layout.",
   "Benchmark mode: treat fake issue framing, fake publication history, fake keyboard shortcuts, invented named contributors, and demo-page behavior as disallowed outputs. Use neutral structural placeholders if needed.",
-  "Benchmark mode: the page should feel publishable, not like a static demo or wireframe explanation."
+  "Benchmark mode: the page should feel publishable, not like a static demo or wireframe explanation.",
+  "Benchmark mode: do not label the page as a demo, benchmark, placeholder, or structural exercise inside the UI."
 ];
 
 const BENCHMARK_SITE_TYPE_RULES = {
@@ -71,7 +72,9 @@ const BENCHMARK_SITE_TYPE_RULES = {
     "Benchmark blog mode: use neutral structural placeholders or concrete subject matter instead of publication worldbuilding or reflective-editorial atmosphere prose.",
     "Benchmark blog mode: do not wrap the page in a generic publication shell like Journal, Featured Essay, Latest Dispatches, Notes, Archive, Print Edition, Submit Work, or similar magazine-site framing.",
     "Benchmark blog mode: avoid the default editorial scaffold of hero, story list, archive rail, topics grid, and publication footer unless the user explicitly asked for a magazine-style site.",
-    "Benchmark blog mode: do not use Tailwind CDN starter theming, Font Awesome chrome, picsum/placehold imagery, fake keyboard/search chrome, or demo-only modal article previews."
+    "Benchmark blog mode: do not use Tailwind CDN starter theming, Font Awesome chrome, picsum/placehold imagery, fake keyboard/search chrome, or demo-only modal article previews.",
+    "Benchmark blog mode: include one real editorial image surface or one authored abstract visual composition. Do not replace visuals with text placeholders.",
+    "Benchmark blog mode: do not invent named authors, editors, contributors, or interview credits unless the user explicitly asked for fictional worldbuilding."
   ],
   store: [
     "Benchmark ecommerce mode: prioritize conversion architecture over editorial styling. The page should sell, not just look clean.",
@@ -79,7 +82,8 @@ const BENCHMARK_SITE_TYPE_RULES = {
     "Benchmark ecommerce mode: do not leave the main merchandising surface as a literal placeholder, dashed demo box, emoji stand-in, or visual wireframe.",
     "Benchmark ecommerce mode: do not use Tailwind CDN starter theming, Font Awesome chrome, or placeholder product images such as picsum/placehold on the live merchandising surface.",
     "Benchmark ecommerce mode: fake command palettes, fake app shortcuts, demo-only cart gimmicks, and unrelated theme chrome are disallowed.",
-    "Benchmark ecommerce mode: fake review counts, fake bestseller labels, fake sales counters, and fake as-featured-in proof are disallowed."
+    "Benchmark ecommerce mode: fake review counts, fake bestseller labels, fake sales counters, and fake as-featured-in proof are disallowed.",
+    "Benchmark ecommerce mode: include a real product-photo surface or an authored product-style render/silhouette. Do not replace the hero with text placeholders."
   ]
 };
 
@@ -234,7 +238,8 @@ const BENCHMARK_STARTERS = {
     "Section 2: one dominant lead piece with a strong headline and one supporting block offset beside or below it.",
     "Section 3: one compact secondary list or pair of entries, not an archive rail plus topics plus notes stack.",
     "Section 4: minimal closing footer note only if needed.",
-    "No publication shell, no archive/topic chrome, no subscribe CTA, no demo interactions, no explanation that the page is a demo."
+    "No publication shell, no archive/topic chrome, no subscribe CTA, no author bylines, no contributor credits, no demo interactions, no explanation that the page is a demo.",
+    "Use one strong visual surface: a real editorial image URL or an authored abstract composition made with CSS/SVG."
   ],
   store: [
     "Benchmark store starter: build a flagship single-product PDP with 4-5 sections max.",
@@ -243,7 +248,9 @@ const BENCHMARK_STARTERS = {
     "Section 3: three focused benefit/features blocks.",
     "Section 4: material/specification or craftsmanship band with objection handling.",
     "Section 5: compact FAQ or guarantee block if still needed.",
-    "No Tailwind starter shell, no fake reviews, no fake badges, no placeholder gallery, no emoji or dashed placeholder hero."
+    "No Tailwind starter shell, no fake reviews, no fake badges, no placeholder gallery, no emoji or dashed placeholder hero, no alert-based checkout, no keyboard shortcut chrome, no demo footer copy.",
+    "The hero must merchandise the product with a believable product surface and product-specific benefit language, not generic luxury-commerce filler.",
+    "Use a real product image URL or an authored SVG/CSS product silhouette with material/shadow treatment. Never use text-only image placeholders."
   ]
 };
 
@@ -275,6 +282,7 @@ const SLOP_PATTERNS = [
   { key: "premium_blog_trope", label: "generic premium-blog editorial trope", pattern: /\b(?:thoughtful living|slow living|curated reflections|crafted with intention|made with intention|a quiet publication|made with restraint|journal of attention|discipline of seeing|private notes made public)\b/i, weight: 2 },
   { key: "reflective_editorial_copy", label: "generic reflective-editorial copy trope", pattern: /\b(?:quiet architecture of attention|great thinkers understood|value of slowness|the examined life|deliberate cultivation of focus|most radical act|what we have forgotten|how everyday items carry|still matters)\b/i, weight: 2 },
   { key: "fictional_publication_brand", label: "invented publication/author scaffolding", pattern: /\b(?:by [A-Z][a-z]+ [A-Z][a-z]+|photography by [A-Z][a-z]+ [A-Z][a-z]+|journal of attention|vesper|lumen|dispatches|vol\.\s*\d+|winter 20\d{2}|autumn 20\d{2}|spring 20\d{2}|summer 20\d{2}|the quarterly|editorial\.)\b/i, weight: 3 },
+  { key: "author_bylines", label: "named author or contributor byline", pattern: /\b(?:by [A-Z][A-Za-z]+(?:\s+[A-Z][A-Za-z]+)+|contributor|essay by|interview by)\b/i, weight: 3 },
   { key: "fake_social_proof", label: "fake reader count or social proof", pattern: /\b(?:\d+\s+readers joined this month|\d+\s+subscribers?|trusted by)\b/i, weight: 2 },
   { key: "placeholder_surface", label: "placeholder surface or stand-in hero", pattern: /\b(?:placeholder|visual placeholder|product representation|hero placeholder|dashed|emoji stand-in|🧥|🎧)\b/i, weight: 3 }
 ];
@@ -308,6 +316,20 @@ function normalizeContent(content) {
   return "";
 }
 
+function isExternalAssetReference(value) {
+  return /^(?:[a-z]+:|\/\/|#|data:|mailto:|tel:)/i.test(String(value || ""));
+}
+
+function extractLocalAssetReferences(htmlText = "") {
+  const refs = new Set();
+  for (const match of String(htmlText).matchAll(/\b(?:href|src)=["']([^"'#?]+(?:\?[^"']*)?)["']/gi)) {
+    const ref = String(match[1] || "").trim();
+    if (!ref || isExternalAssetReference(ref)) continue;
+    refs.add(ref.split("?")[0]);
+  }
+  return [...refs];
+}
+
 function inferMimeType(filePath) {
   const lower = String(filePath || "").toLowerCase();
   if (lower.endsWith(".png")) return "image/png";
@@ -489,6 +511,10 @@ export function detectFrontendSlop({ promptText = "", assistantText = "", receip
     flags.push("benchmark store used fake proof or badge chrome");
     score += 4;
   }
+  if (siteType === "store" && benchmarkMode && /\b(?:Objects for a considered life|considered life|timeless essentials|designed for modern living)\b/i.test(haystack)) {
+    flags.push("benchmark store fell back to generic luxury-commerce copy");
+    score += 2;
+  }
   if (siteType === "store" && benchmarkMode && /\b(?:metaKey && e\.key === ['"]k['"]|command palette|keyboard shortcuts?)\b/i.test(haystack)) {
     flags.push("benchmark store used fake keyboard or shortcut chrome");
     score += 4;
@@ -517,6 +543,10 @@ export function detectFrontendSlop({ promptText = "", assistantText = "", receip
     flags.push("benchmark blog fell back to essay-magazine placeholder language");
     score += 3;
   }
+  if (siteType === "blog" && benchmarkMode && /\b(?:by [A-Z][A-Za-z]+(?:\s+[A-Z][A-Za-z]+)+|contributor|essay by|interview by)\b/i.test(haystack)) {
+    flags.push("benchmark blog used invented author or contributor bylines");
+    score += 4;
+  }
   if (siteType === "blog" && benchmarkMode && /cdn\.tailwindcss\.com/i.test(haystack)) {
     flags.push("benchmark blog relied on Tailwind CDN starter theming");
     score += 4;
@@ -551,12 +581,78 @@ export function detectFrontendSlop({ promptText = "", assistantText = "", receip
   return {
     score,
     flags,
-    hardBlock: flags.some((flag) => /fictional publication identity|generic publication-shell framing|essay-magazine placeholder language|fake keyboard|reflective-editorial atmosphere|primary merchandising surface as a placeholder|placeholder hero surface|Tailwind CDN starter theming|Font Awesome chrome|placeholder product imagery|placeholder imagery|fake proof or badge chrome|demo interaction chrome|demo page explanation copy/.test(flag)),
+    hardBlock: flags.some((flag) => /fictional publication identity|generic publication-shell framing|essay-magazine placeholder language|invented author or contributor bylines|fake keyboard|reflective-editorial atmosphere|primary merchandising surface as a placeholder|placeholder hero surface|Tailwind CDN starter theming|Font Awesome chrome|placeholder product imagery|placeholder imagery|fake proof or badge chrome|demo interaction chrome|demo page explanation copy/.test(flag)),
     severe: score >= 5,
     summary: flags.length > 0 ? `frontend slop flags: ${flags.join(", ")}` : "no deterministic frontend slop flags"
   };
 }
 
+export async function inspectFrontendArtifacts({ cwd, receipt = null, frontend = null } = {}) {
+  const changedFiles = Array.isArray(receipt?.changedFiles) ? receipt.changedFiles : [];
+  const htmlFiles = changedFiles
+    .map((filePath) => String(filePath || "").trim())
+    .filter((filePath) => filePath && filePath.toLowerCase().endsWith(".html"));
+  const flags = [];
+  let score = 0;
+
+  for (const filePath of htmlFiles) {
+    const absolute = path.isAbsolute(filePath) ? filePath : path.resolve(cwd || process.cwd(), filePath);
+    let htmlText = "";
+    try {
+      htmlText = await fs.readFile(absolute, "utf8");
+    } catch {
+      continue;
+    }
+
+    const localRefs = extractLocalAssetReferences(htmlText);
+    for (const ref of localRefs) {
+      const target = path.resolve(path.dirname(absolute), ref);
+      try {
+        await fs.access(target);
+      } catch {
+        flags.push(`missing local asset reference: ${ref}`);
+        score += 4;
+      }
+    }
+
+    if (frontend?.benchmarkMode) {
+      const hasVisualSurface = /<img\b|background-image\s*:|url\((?!['"]?(?:https?:|data:))/i.test(htmlText) || /<svg\b/i.test(htmlText);
+      const hasPlaceholderSurface = /\b(?:visual-placeholder|image-placeholder|replace with high[- ]resolution|replace with high quality photography|text-only image placeholder|product representation)\b/i.test(htmlText);
+      if (!hasVisualSurface || hasPlaceholderSurface) {
+        flags.push(`benchmark ${frontend.siteType} lacks a real visual surface`);
+        score += 4;
+      }
+      if (/\b(?:console\.log|alert\(|prompt\(|static demo|demo product page|all content is placeholder)\b/i.test(htmlText)) {
+        flags.push(`benchmark ${frontend.siteType} still contains demo behavior or explanation copy`);
+        score += 3;
+      }
+    }
+  }
+
+  return {
+    score,
+    flags: [...new Set(flags)],
+    hardBlock: flags.length > 0,
+    severe: score >= 5,
+    summary: flags.length ? `frontend artifact issues: ${[...new Set(flags)].join(", ")}` : "no frontend artifact issues"
+  };
+}
+
+export function mergeFrontendSlop(base = null, extra = null) {
+  if (!base && !extra) return null;
+  if (!base) return extra;
+  if (!extra) return base;
+  const flags = [...new Set([...(base.flags || []), ...(extra.flags || [])])];
+  const score = Number(base.score || 0) + Number(extra.score || 0);
+  return {
+    score,
+    flags,
+    hardBlock: Boolean(base.hardBlock || extra.hardBlock),
+    severe: score >= 5 || Boolean(base.severe || extra.severe),
+    summary: flags.length ? `frontend slop flags: ${flags.join(", ")}` : "no deterministic frontend slop flags"
+  };
+}
+
 export function shouldAutoReviseFrontend({ designReview = null, slop = null, revisionCount = 0 } = {}) {
   if (revisionCount >= 3) return false;
   if (!designReview) return false;

package/src/prompt.js

@@ -6,67 +6,51 @@ export async function promptLine(label, { input = process.stdin, output = proces
       return;
     }
     let buf = "";
-    let resolved = false;
-    const shouldPauseOnCleanup = typeof input.pause === "function";
+    let settled = false;
     const isTTY = input.isTTY && typeof input.setRawMode === "function";
 
-    function cleanup() {
-      resolved = true;
+    // Steal stdin from existing data listeners (readline keypress emitter, etc.)
+    const stolenListeners = input.rawListeners("data").slice();
+    for (const fn of stolenListeners) input.removeListener("data", fn);
+
+    function finish(value, err) {
+      if (settled) return;
+      settled = true;
       input.removeListener("data", onData);
       if (signal) signal.removeEventListener("abort", onAbort);
-      if (isTTY) {
-        try { input.setRawMode(false); } catch {}
-      }
-      if (shouldPauseOnCleanup) {
-        try {
-          input.pause();
-        } catch {}
-      }
+      if (isTTY) { try { input.setRawMode(false); } catch {} }
+      try { input.pause(); } catch {}
+      // Restore stolen listeners
+      for (const fn of stolenListeners) input.on("data", fn);
+      if (err) reject(err);
+      else resolve(value);
     }
+
     function onData(chunk) {
-      if (resolved) return;
+      if (settled) return;
       const str = chunk.toString();
       for (const ch of str) {
         if (ch === "\r") continue;
-        if (ch === "\n") {
-          cleanup();
-          output.write("\n");
-          resolve(buf);
-          return;
-        }
-        if (ch === "\u0003") {
-          cleanup();
-          reject(new DOMException("The operation was aborted.", "AbortError"));
-          return;
-        }
-        // Backspace
+        if (ch === "\n") { output.write("\n"); finish(buf); return; }
+        if (ch === "\u0003") { finish("", new DOMException("The operation was aborted.", "AbortError")); return; }
         if (ch === "\u007f" || ch === "\b") {
-          if (buf.length > 0) {
-            buf = buf.slice(0, -1);
-            output.write("\b \b");
-          }
+          if (buf.length > 0) { buf = buf.slice(0, -1); output.write("\b \b"); }
           continue;
         }
-        // Skip non-printable control chars
         if (ch.charCodeAt(0) < 32) continue;
         buf += ch;
         output.write(ch);
       }
     }
+
     function onAbort() {
-      if (resolved) return;
-      cleanup();
-      reject(signal.reason || new DOMException("The operation was aborted.", "AbortError"));
+      finish("", signal.reason || new DOMException("The operation was aborted.", "AbortError"));
     }
 
-    // Ensure clean stdin state before listening
-    if (isTTY) {
-      try { input.setRawMode(false); } catch {}
-    }
+    // Clean stdin state
+    if (isTTY) { try { input.setRawMode(false); } catch {} }
     input.pause();
-    if (isTTY) {
-      input.setRawMode(true);
-    }
+    if (isTTY) input.setRawMode(true);
     input.on("data", onData);
     input.resume();
     if (signal) signal.addEventListener("abort", onAbort, { once: true });

package/src/workflow.js

@@ -8,6 +8,8 @@ import {
   captureFrontendScreenshot,
   detectFrontendSlop,
   findFrontendPreviewEntry,
+  inspectFrontendArtifacts,
+  mergeFrontendSlop,
   reviewFrontendTurn,
   reviewFrontendScreenshot,
   shouldForceFrontendRebuild,
@@ -180,9 +182,13 @@ export async function runBuildWorkflow({
       }
     }
 
-    const designSlop = designReview
+    const deterministicSlop = designReview
       ? detectFrontendSlop({ promptText, assistantText: activeResponse.content || "", receipt: activeReceipt, designReview })
       : null;
+    const artifactSlop = designReview
+      ? await inspectFrontendArtifacts({ cwd: context.cwd, receipt: activeReceipt, frontend: frontendCtx?.frontend || null })
+      : null;
+    const designSlop = mergeFrontendSlop(deterministicSlop, artifactSlop);
 
     return { impact, review, designReview, designSlop, screenshotReview, screenshotPath };
   }