@tritard/waterbrother 0.8.13 → 0.8.15

package/package.json

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

package/src/cli.js

@@ -861,6 +861,18 @@ function printReceiptSummary(receipt) {
           : yellow("caution");
     console.log(`${styleSystemPrefix()} ${dim("design")} ${verdict} ${receipt.designReview.summary || ""}`.trim());
   }
+  if (receipt.designRevision?.triggered) {
+    console.log(`${styleSystemPrefix()} ${dim("design pass")} ${yellow("auto-revised")} ${receipt.designRevision.initialSummary || ""}`.trim());
+  }
+  if (receipt.screenshotReview?.verdict) {
+    const verdict =
+      receipt.screenshotReview.verdict === "strong"
+        ? green("strong")
+        : receipt.screenshotReview.verdict === "weak"
+          ? red("weak")
+          : yellow("caution");
+    console.log(`${styleSystemPrefix()} ${dim("render")} ${verdict} ${receipt.screenshotReview.summary || ""}`.trim());
+  }
 }
 
 function printImpactMap(impact) {
@@ -5384,6 +5396,14 @@ async function promptLoop(agent, session, context) {
           const vc = v === "strong" ? green(v) : v === "weak" ? red(v) : yellow(v);
           lines.push(`${dim("design:")} ${vc} — ${buildResult.designReview.summary}`);
         }
+        if (buildResult.screenshotReview) {
+          const v = buildResult.screenshotReview.verdict;
+          const vc = v === "strong" ? green(v) : v === "weak" ? red(v) : yellow(v);
+          lines.push(`${dim("render:")} ${vc} — ${buildResult.screenshotReview.summary}`);
+        }
+        if (buildResult.designRevision?.triggered) {
+          lines.push(`${dim("design pass:")} ${yellow("auto-revised")} — ${buildResult.designRevision.initialSummary || "first pass revised"}`);
+        }
 
         // Task state
         lines.push(`${dim("task:")} ${task.name} → ${cyan("review-ready")}`);

package/src/frontend.js

@@ -1,5 +1,13 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { promisify } from "node:util";
 import { createChatCompletion } from "./grok-client.js";
 
+const execFileAsync = promisify(execFile);
+
 const FRONTEND_REVIEW_SYSTEM_PROMPT = `You are Waterbrother Art Director, a strict frontend design critic.
 You review generated websites, landing pages, blogs, and UI surfaces after implementation.
 Judge the work against these standards:
@@ -23,6 +31,22 @@ Rules:
 - Call out fake credibility badges, placeholder brands, stock-image dependence, Tailwind CDN template styling, and overused serif/sans premium-blog tropes when present.
 - Do not wrap JSON in markdown.`;
 
+const FRONTEND_SCREENSHOT_REVIEW_SYSTEM_PROMPT = `You are Waterbrother Art Director reviewing a rendered website screenshot.
+Judge the actual visual result on screen, not the code alone.
+
+Return strict JSON with keys:
+- verdict: one of strong, caution, weak
+- summary: short string
+- wins: array of strings
+- visualIssues: array of strings
+- nextPass: array of strings
+
+Rules:
+- Use weak for obvious template output, weak hierarchy, awkward spacing, generic composition, or visually incoherent pages.
+- Use caution for competent pages that still feel safe, generic, or under-directed.
+- Be concrete about visible layout, spacing, typography, contrast, composition, and interaction cues.
+- Do not wrap JSON in markdown.`;
+
 const SITE_TYPES = [
   ["blog", /\b(blog|journal|essays?|articles?|publication|editorial)\b/i],
   ["landing", /\b(landing page|homepage|home page|marketing site|product site|launch page|hero section)\b/i],
@@ -47,6 +71,50 @@ const AUDIENCE_HINTS = [
   ["operators", /\b(founders?|operators?|engineers?|designers?)\b/i]
 ];
 
+const ARCHETYPE_RULES = {
+  "editorial-minimal": [
+    "Use restrained editorial hierarchy with fewer, larger blocks of content.",
+    "Favor margins, type rhythm, and restraint over decorative UI.",
+    "Keep the palette quiet and avoid loud CTA-heavy marketing patterns."
+  ],
+  "luxury-magazine": [
+    "Use strong type contrast and asymmetry, but avoid fake prestige or fashion cliché overload.",
+    "Make one or two sections do the visual heavy lifting instead of many repetitive cards.",
+    "Let spacing and composition carry the premium feel more than gradients or gimmicks."
+  ],
+  "founder-journal": [
+    "Keep the voice direct and personal rather than generic lifestyle-editorial.",
+    "Use sparse structure and strong notebook-like pacing.",
+    "Avoid fake magazine tropes and unnecessary promotional UI."
+  ],
+  "brutalist-culture": [
+    "Prioritize bold hierarchy, high contrast, and deliberate rawness.",
+    "Use fewer colors and stronger typographic tension.",
+    "Avoid soft premium-blog aesthetics."
+  ],
+  "high-contrast-tech": [
+    "Use a colder palette, harder edges, and precise spacing.",
+    "Prefer technical clarity over lifestyle editorial softness.",
+    "Avoid generic startup landing-page sections unless they are explicitly requested."
+  ],
+  "quiet-portfolio": [
+    "Let work and case-study structure carry the page, not decorative chrome.",
+    "Use calm spacing and image framing with minimal interface noise.",
+    "Avoid blog-style editorial filler."
+  ]
+};
+
+const SLOP_PATTERNS = [
+  { key: "placeholder_images", label: "placeholder image service", pattern: /\b(?:picsum\.photos|placehold\.co|placeholder\.com)\b/i, weight: 3 },
+  { key: "tailwind_cdn", label: "Tailwind CDN starter styling", pattern: /cdn\.tailwindcss\.com/i, weight: 2 },
+  { key: "inter_playfair", label: "generic Inter/Playfair premium pairing", pattern: /Inter|Playfair\s+Display/i, weight: 2 },
+  { key: "fake_prestige", label: "fake prestige or publication badge", pattern: /\b(?:featured in|as seen in|forbes|the atlantic|wall street journal|award-winning)\b/i, weight: 3 },
+  { key: "fake_founder_lore", label: "fake founder or studio lore", pattern: /\b(?:founded in|est\s+20\d{2}|from the studio|published from a small studio|founder\s*&\s*essayist)\b/i, weight: 2 },
+  { key: "newsletter_cliche", label: "generic newsletter promise copy", pattern: /\b(?:no spam, ever|respect your inbox|join the newsletter|subscribe to the journal)\b/i, weight: 1 },
+  { key: "fake_ui_chrome", label: "fake low-value UI chrome", pattern: /\b(?:search|filterCategory|showPostModal|toggleSearch|Latest Stories|Recent Dispatches)\b/i, weight: 1 },
+  { key: "premium_blog_trope", label: "generic premium-blog editorial trope", pattern: /\b(?:thoughtful living|slow living|curated reflections|crafted with intention|made with intention)\b/i, weight: 2 }
+];
+
 function normalizeContent(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -58,6 +126,21 @@ function normalizeContent(content) {
   return "";
 }
 
+function inferMimeType(filePath) {
+  const lower = String(filePath || "").toLowerCase();
+  if (lower.endsWith(".png")) return "image/png";
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".webp")) return "image/webp";
+  if (lower.endsWith(".gif")) return "image/gif";
+  return "application/octet-stream";
+}
+
+async function loadImageAsDataUrl(filePath) {
+  const raw = await fs.readFile(filePath);
+  const mime = inferMimeType(filePath);
+  return `data:${mime};base64,${raw.toString("base64")}`;
+}
+
 function parseJsonObject(text) {
   const raw = String(text || "").trim();
   if (!raw) return null;
@@ -127,7 +210,8 @@ export function buildFrontendExecutionContext({ promptText = "", profile = "code
     "Prefer hand-authored CSS variables and layout rules over generic template utility sprawl when feasible.",
     "Cut fake credibility elements, fake brands, fake testimonials, and filler interface chrome unless explicitly requested.",
     "Avoid placeholder image services, Inter/Playfair default pairings, Tailwind CDN starter aesthetics, and generic premium-blog tropes.",
-    "Prefer fewer sections with stronger hierarchy over a long page full of low-value widgets."
+    "Prefer fewer sections with stronger hierarchy over a long page full of low-value widgets.",
+    ...(ARCHETYPE_RULES[archetype] || [])
   ].join("\n");
 
   return {
@@ -156,6 +240,66 @@ export function shouldRunFrontendReview({ promptText = "", receipt = null, profi
   return changedFiles.some((filePath) => isFrontendFile(filePath));
 }
 
+export function detectFrontendSlop({ promptText = "", assistantText = "", receipt = null, designReview = null } = {}) {
+  const haystack = [
+    String(promptText || ""),
+    String(assistantText || ""),
+    String(receipt?.diff || ""),
+    Array.isArray(receipt?.changedFiles) ? receipt.changedFiles.join("\n") : ""
+  ].join("\n");
+  const flags = [];
+  let score = 0;
+  for (const item of SLOP_PATTERNS) {
+    if (item.pattern.test(haystack)) {
+      flags.push(item.label);
+      score += item.weight;
+    }
+  }
+  if (designReview?.verdict === "weak") score += 3;
+  else if (designReview?.verdict === "caution") score += 1;
+  return {
+    score,
+    flags,
+    severe: score >= 5,
+    summary: flags.length > 0 ? `frontend slop flags: ${flags.join(", ")}` : "no deterministic frontend slop flags"
+  };
+}
+
+export function shouldAutoReviseFrontend({ designReview = null, slop = null, revisionCount = 0 } = {}) {
+  if (revisionCount >= 1) return false;
+  if (!designReview) return false;
+  if (designReview.verdict === "weak") return true;
+  if (designReview.verdict === "caution" && (slop?.score || 0) >= 3) return true;
+  return false;
+}
+
+export function buildFrontendRevisionPrompt({
+  originalPrompt = "",
+  designReview = null,
+  slop = null,
+  screenshotReview = null
+} = {}) {
+  const issues = Array.isArray(designReview?.issues) ? designReview.issues.slice(0, 6) : [];
+  const nextPass = Array.isArray(designReview?.nextPass) ? designReview.nextPass.slice(0, 6) : [];
+  const slopFlags = Array.isArray(slop?.flags) ? slop.flags.slice(0, 6) : [];
+  const visualIssues = Array.isArray(screenshotReview?.visualIssues) ? screenshotReview.visualIssues.slice(0, 6) : [];
+  const visualNextPass = Array.isArray(screenshotReview?.nextPass) ? screenshotReview.nextPass.slice(0, 6) : [];
+  const blocks = [
+    `Revise the generated frontend to address the design problems from the first pass.`,
+    `Original task: ${String(originalPrompt || "").trim()}`,
+    issues.length > 0 ? `Problems to fix:\n- ${issues.join("\n- ")}` : "",
+    visualIssues.length > 0 ? `Visible screenshot problems:\n- ${visualIssues.join("\n- ")}` : "",
+    slopFlags.length > 0 ? `Deterministic slop flags:\n- ${slopFlags.join("\n- ")}` : "",
+    nextPass.length > 0 ? `Revision priorities:\n- ${nextPass.join("\n- ")}` : "",
+    visualNextPass.length > 0 ? `Screenshot revision priorities:\n- ${visualNextPass.join("\n- ")}` : "",
+    "Do not add new filler sections.",
+    "Do not add fake prestige, fake testimonials, fake brands, or placeholder-image services.",
+    "Simplify the page if needed. Stronger direction with fewer elements is preferred over busier generic output.",
+    "Rewrite the weakest sections rather than making superficial tweaks."
+  ].filter(Boolean);
+  return blocks.join("\n\n");
+}
+
 function normalizeFrontendReview(review) {
   const verdict = String(review?.verdict || "caution").trim().toLowerCase();
   return {
@@ -167,6 +311,17 @@ function normalizeFrontendReview(review) {
   };
 }
 
+function normalizeScreenshotReview(review) {
+  const verdict = String(review?.verdict || "caution").trim().toLowerCase();
+  return {
+    verdict: ["strong", "caution", "weak"].includes(verdict) ? verdict : "caution",
+    summary: String(review?.summary || "No screenshot review summary returned.").trim(),
+    wins: Array.isArray(review?.wins) ? review.wins.map((item) => String(item || "").trim()).filter(Boolean).slice(0, 8) : [],
+    visualIssues: Array.isArray(review?.visualIssues) ? review.visualIssues.map((item) => String(item || "").trim()).filter(Boolean).slice(0, 8) : [],
+    nextPass: Array.isArray(review?.nextPass) ? review.nextPass.map((item) => String(item || "").trim()).filter(Boolean).slice(0, 8) : []
+  };
+}
+
 export async function reviewFrontendTurn({
   apiKey,
   baseUrl,
@@ -200,3 +355,93 @@ export async function reviewFrontendTurn({
   const parsed = parseJsonObject(normalizeContent(completion?.message?.content));
   return normalizeFrontendReview(parsed || {});
 }
+
+export async function findFrontendPreviewEntry({ cwd, receipt = null } = {}) {
+  const changedFiles = Array.isArray(receipt?.changedFiles) ? receipt.changedFiles : [];
+  for (const filePath of changedFiles) {
+    const raw = String(filePath || "").trim();
+    if (!raw) continue;
+    const absolute = path.isAbsolute(raw) ? raw : path.resolve(cwd || process.cwd(), raw);
+    if (!absolute.toLowerCase().endsWith(".html")) continue;
+    try {
+      await fs.access(absolute);
+      return absolute;
+    } catch {}
+  }
+  const fallback = path.resolve(cwd || process.cwd(), "index.html");
+  try {
+    await fs.access(fallback);
+    return fallback;
+  } catch {
+    return null;
+  }
+}
+
+export async function captureFrontendScreenshot({ entryPath } = {}) {
+  if (!entryPath || process.platform !== "darwin") return null;
+  const screenshotPath = path.join(os.tmpdir(), `waterbrother-frontend-${Date.now()}.png`);
+  const targetUrl = pathToFileURL(entryPath).toString();
+  const script = `
+on run argv
+  set targetUrl to item 1 of argv
+  set outputPath to item 2 of argv
+  set leftPos to 72
+  set topPos to 56
+  set rightPos to 1512
+  set bottomPos to 1120
+  tell application "Safari"
+    activate
+    make new document with properties {URL:targetUrl}
+    delay 2
+    try
+      set bounds of front window to {leftPos, topPos, rightPos, bottomPos}
+    end try
+    delay 1
+    set winBounds to bounds of front window
+  end tell
+  set captureLeft to item 1 of winBounds
+  set captureTop to item 2 of winBounds
+  set captureWidth to (item 3 of winBounds) - (item 1 of winBounds)
+  set captureHeight to (item 4 of winBounds) - (item 2 of winBounds)
+  do shell script "/usr/sbin/screencapture -x -R" & quoted form of ((captureLeft as string) & "," & (captureTop as string) & "," & (captureWidth as string) & "," & (captureHeight as string)) & " " & quoted form of outputPath
+  tell application "Safari"
+    try
+      close front document saving no
+    end try
+  end tell
+  return outputPath
+end run`;
+  await execFileAsync("/usr/bin/osascript", ["-e", script, targetUrl, screenshotPath], { timeout: 12000 });
+  return screenshotPath;
+}
+
+export async function reviewFrontendScreenshot({
+  apiKey,
+  baseUrl,
+  model,
+  screenshotPath,
+  promptText = "",
+  signal
+} = {}) {
+  if (!screenshotPath) return null;
+  const imageUrl = await loadImageAsDataUrl(screenshotPath);
+  const completion = await createChatCompletion({
+    apiKey,
+    baseUrl,
+    model,
+    signal,
+    messages: [
+      { role: "system", content: FRONTEND_SCREENSHOT_REVIEW_SYSTEM_PROMPT },
+      {
+        role: "user",
+        content: [
+          { type: "text", text: `Audit this rendered frontend screenshot for the task: ${String(promptText || "").slice(0, 4000)}` },
+          { type: "image_url", image_url: { url: imageUrl } }
+        ]
+      }
+    ]
+  });
+
+  const parsed = parseJsonObject(normalizeContent(completion?.message?.content));
+  return normalizeScreenshotReview(parsed || {});
+}

package/src/workflow.js

@@ -1,7 +1,17 @@
 import { createTask, findTaskByName, saveTask, slugify } from "./task-store.js";
 import { computeImpactMap, summarizeImpactMap } from "./impact.js";
 import { reviewTurn, challengeReceipt } from "./reviewer.js";
-import { buildFrontendExecutionContext, reviewFrontendTurn, shouldRunFrontendReview } from "./frontend.js";
+import {
+  buildFrontendExecutionContext,
+  buildFrontendRevisionPrompt,
+  captureFrontendScreenshot,
+  detectFrontendSlop,
+  findFrontendPreviewEntry,
+  reviewFrontendTurn,
+  reviewFrontendScreenshot,
+  shouldAutoReviseFrontend,
+  shouldRunFrontendReview
+} from "./frontend.js";
 import { runPlannerPass, formatPlanForExecutor, formatPlanForDisplay } from "./planner.js";
 
 export async function runBuildWorkflow({
@@ -78,70 +88,138 @@ export async function runBuildWorkflow({
     : promptText;
 
   // Run the turn
-  const response = await agent.runBuildTurn(executorPrompt, handlers);
+  let response = await agent.runBuildTurn(executorPrompt, handlers);
 
   // Complete turn and get receipt
-  const receipt = await agent.toolRuntime.completeTurn({ signal: handlers.signal });
+  let receipt = await agent.toolRuntime.completeTurn({ signal: handlers.signal });
 
   if (!receipt) {
     return { response, receipt: null, impact: null, review: null };
   }
 
-  // Run impact analysis
-  let 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
-    });
-  }
-
-  // Run sentinel review
-  let 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: response.content || "",
-        receipt: { ...receipt, diff: receipt.diff || "" },
-        impact,
-        maxDiffChars: context.runtime.reviewer?.maxDiffChars,
-        signal: handlers.signal
+  async function analyze(activeReceipt, activeResponse) {
+    let impact = null;
+    if (activeReceipt.mutated && context.runtime.impact?.enabled !== false) {
+      impact = await computeImpactMap({
+        cwd: context.cwd,
+        changedFiles: activeReceipt.changedFiles || [],
+        maxRelated: context.runtime.impact?.maxRelated,
+        maxTests: context.runtime.impact?.maxTests
       });
-    } catch (error) {
-      review = {
-        verdict: "caution",
-        summary: `review failed: ${error instanceof Error ? error.message : String(error)}`,
-        concerns: ["Sentinel reviewer could not complete."],
-        followups: []
-      };
     }
+
+    let review = null;
+    if (activeReceipt.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: activeResponse.content || "",
+          receipt: { ...activeReceipt, diff: activeReceipt.diff || "" },
+          impact,
+          maxDiffChars: context.runtime.reviewer?.maxDiffChars,
+          signal: handlers.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 = null;
+    if (shouldRunFrontendReview({ promptText, receipt: activeReceipt, profile: agent.getProfile() })) {
+      try {
+        designReview = await reviewFrontendTurn({
+          apiKey: context.runtime.apiKey,
+          baseUrl: context.runtime.baseUrl,
+          model: context.runtime.reviewer?.model || agent.getModel(),
+          promptText,
+          assistantText: activeResponse.content || "",
+          receipt: { ...activeReceipt, diff: activeReceipt.diff || "" },
+          signal: handlers.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: activeReceipt });
+        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: handlers.signal
+            });
+          }
+        }
+      } catch {
+        screenshotReview = null;
+      }
+    }
+
+    const designSlop = designReview
+      ? detectFrontendSlop({ promptText, assistantText: activeResponse.content || "", receipt: activeReceipt, designReview })
+      : null;
+
+    return { impact, review, designReview, designSlop, screenshotReview, screenshotPath };
   }
 
-  let 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: response.content || "",
-        receipt: { ...receipt, diff: receipt.diff || "" },
-        signal: handlers.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 { impact, review, designReview, designSlop, screenshotReview, screenshotPath } = await analyze(receipt, response);
+  let designRevision = null;
+
+  if (shouldAutoReviseFrontend({ designReview, slop: designSlop, revisionCount: 0 })) {
+    const firstPassVerdict = designReview?.verdict || null;
+    const firstPassSummary = String(designReview?.summary || "").trim();
+    const firstPassSlopFlags = Array.isArray(designSlop?.flags) ? [...designSlop.flags] : [];
+    const revisionPrompt = buildFrontendRevisionPrompt({
+      originalPrompt: promptText,
+      designReview,
+      slop: designSlop,
+      screenshotReview
+    });
+    const revisionCtx = {
+      ...executionCtx,
+      phase: "design-revision",
+      reminders: [
+        executionCtx.reminders || "",
+        "Automatic second pass: fix the flagged frontend design issues without widening scope."
+      ].filter(Boolean).join("\n")
+    };
+    agent.setExecutionContext(revisionCtx);
+    if (task.activeContract) {
+      agent.toolRuntime.setCurrentContract(task.activeContract);
+    }
+    response = await agent.runBuildTurn(revisionPrompt, handlers);
+    const revisedReceipt = await agent.toolRuntime.completeTurn({ signal: handlers.signal });
+    if (revisedReceipt) {
+      receipt = revisedReceipt;
+      ({ impact, review, designReview, designSlop, screenshotReview, screenshotPath } = await analyze(receipt, response));
+      designRevision = {
+        triggered: true,
+        firstPassVerdict,
+        initialSummary: firstPassSummary,
+        slopFlags: firstPassSlopFlags
       };
     }
   }
@@ -151,6 +229,10 @@ export async function runBuildWorkflow({
   if (impact) updates.impact = impact;
   if (review) updates.review = review;
   if (designReview) updates.designReview = designReview;
+  if (designSlop) updates.designSlop = designSlop;
+  if (screenshotReview) updates.screenshotReview = screenshotReview;
+  if (screenshotPath) updates.screenshotPath = screenshotPath;
+  if (designRevision) updates.designRevision = designRevision;
   let finalReceipt = receipt;
   if (Object.keys(updates).length > 0) {
     finalReceipt = await agent.toolRuntime.updateReceipt(receipt.id, updates) || receipt;
@@ -176,6 +258,7 @@ export async function runBuildWorkflow({
     impact,
     review,
     designReview,
+    screenshotReview,
     impactSummary: impact ? summarizeImpactMap(impact) : null
   };
 }