jerob 1.0.0

package/plan/browser-agent/executor.ts

@@ -0,0 +1,372 @@
+import { Stagehand } from "@browserbasehq/stagehand";
+import { existsSync, mkdirSync } from "fs";
+import path, { resolve } from "path";
+import type { BrowserPlan, ExecutionResult } from "./types";
+
+const DOWNLOADS_PATH = resolve("C:/Users/SWEETY/Downloads");
+
+let globalStagehand: InstanceType<typeof Stagehand> | null = null;
+
+function getStagehandClient(): InstanceType<typeof Stagehand> {
+  if (!globalStagehand) {
+    globalStagehand = new Stagehand({
+      env: "LOCAL",
+       localBrowserLaunchOptions: {
+    headless: false, // Show browser window
+    // devtools: true, // Open developer tools
+    port: 9222, // Fixed CDP debugging port
+    args: [
+      '--no-sandbox',
+      '--disable-setuid-sandbox',
+      '--disable-web-security',
+      '--allow-running-insecure-content',
+    ],
+    chromiumSandbox: false, // Disable sandbox (adds --no-sandbox)
+    ignoreHTTPSErrors: true, // Ignore certificate errors
+    locale: 'en-US', // Set browser language
+    deviceScaleFactor: 1.0, // Display scaling
+    downloadsPath: './downloads', // Download directory
+    acceptDownloads: true, // Allow downloads
+    connectTimeoutMs: 30000, // Connection timeout
+    executablePath:"C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"
+  },
+      model: {
+        modelName: "google/gemini-3.1-flash-lite-preview",
+        apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY,
+      },
+    });
+  }
+  return globalStagehand;
+}
+
+// Tools whose output is giant DOM/accessibility blobs — skip entirely
+const SKIP_TOOL_OUTPUT = new Set(["ariaTree", "screenshot", "cdpSnapshot"]);
+
+/**
+ * Parses stagehand agent messages into a compact, evaluator-friendly transcript.
+ *
+ * Stagehand message shapes (confirmed from live logs):
+ *
+ * assistant: { role:"assistant", content: [
+ *   { type:"tool-call", toolName, input, ... }   <- agent action intent
+ *   { type:"text",      text: "..."           }   <- agent's SUMMARY / reasoning text
+ * ]}
+ *
+ * tool: { role:"tool", content: [
+ *   { type:"tool-result", toolName, output: { type:"json"|"content", value:... } }
+ * ]}
+ *
+ * Strategy:
+ *  - assistant[type=text]       → the agent's written summary/reasoning — MOST VALUABLE
+ *  - done[input.reasoning]      → agent's stated reason for finishing
+ *  - extract[output]            → structured data
+ *  - navigate/act/wait/goto     → one-line confirmation (success + brief detail)
+ *  - ariaTree/screenshot        → SKIPPED (too large, no signal for evaluator)
+ */
+function parseAgentMessages(messages: unknown[]): {
+  transcript: string;
+  extractedData: unknown;
+} {
+  if (!Array.isArray(messages)) return { transcript: "", extractedData: null };
+
+  const summaryTexts: string[] = [];   // agent's written text — highest priority
+  const actionLines: string[] = [];    // tool confirmations — supporting context
+  const allExtracts: unknown[] = [];
+
+  for (const msg of messages) {
+    if (typeof msg !== "object" || msg === null) continue;
+    const role: string = (msg as any).role ?? "";
+    const content: unknown = (msg as any).content;
+    const items: unknown[] = Array.isArray(content) ? content : [];
+
+    // ── assistant messages ────────────────────────────────────────────
+    if (role === "assistant") {
+      for (const item of items) {
+        if (typeof item !== "object" || item === null) continue;
+        const type: string = (item as any).type ?? "";
+
+        // {type:"text"} — this is the agent's written summary/answer
+        if (type === "text") {
+          const text = String((item as any).text ?? "").trim();
+          if (text) summaryTexts.push(text);
+        }
+
+        // {type:"tool-call", toolName:"done"} — capture reasoning from input
+        if (type === "tool-call" && (item as any).toolName === "done") {
+          const reasoning = (item as any).input?.reasoning;
+          if (typeof reasoning === "string" && reasoning.trim()) {
+            summaryTexts.push(`[DONE REASON] ${reasoning.trim()}`);
+          }
+        }
+      }
+      continue;
+    }
+
+    // ── tool result messages ──────────────────────────────────────────
+    if (role === "tool") {
+      for (const item of items) {
+        if (typeof item !== "object" || item === null) continue;
+        const toolName: string = (item as any).toolName ?? (item as any).name ?? "tool";
+        const output: unknown = (item as any).output;
+
+        // Skip large DOM blobs — useless to evaluator
+        if (SKIP_TOOL_OUTPUT.has(toolName)) continue;
+
+        // extract — capture structured data
+        if (toolName === "extract") {
+          const structured = extractStructured(output);
+          if (structured != null) allExtracts.push(structured);
+          actionLines.push(`[EXTRACT] ${JSON.stringify(structured ?? output)}`);
+          continue;
+        }
+
+        // done tool result — just note success
+        if (toolName === "done") {
+          const val = getOutputValue(output);
+          const ok = (val as any)?.success ?? (val as any)?.taskComplete ?? true;
+          actionLines.push(`[DONE] taskComplete=${ok}`);
+          continue;
+        }
+
+        // navigate / goto / act / wait / scroll / click / type
+        // Pull only the minimal success+detail line — not the whole DOM
+        const val = getOutputValue(output);
+        if (val != null) {
+          const success = (val as any)?.success;
+          const url = (val as any)?.url;
+          const action = (val as any)?.action;
+          const waited = (val as any)?.waited;
+          const detail = url ?? action ?? waited ?? "";
+          const line = [
+            `success=${success ?? "?"}`,
+            detail ? String(detail) : "",
+          ]
+            .filter(Boolean)
+            .join(" ");
+          actionLines.push(`[${toolName.toUpperCase()}] ${line}`);
+        }
+      }
+    }
+  }
+
+  const extractedData =
+    allExtracts.length === 1
+      ? allExtracts[0]
+      : allExtracts.length > 1
+        ? allExtracts
+        : null;
+
+  // Build compact transcript: summaries first (most signal), then action log
+  const parts: string[] = [];
+  if (summaryTexts.length > 0) {
+    parts.push("=== AGENT OUTPUT ===");
+    parts.push(summaryTexts.join("\n\n"));
+  }
+  if (actionLines.length > 0) {
+    parts.push("=== ACTION LOG ===");
+    parts.push(actionLines.join("\n"));
+  }
+
+  return { transcript: parts.join("\n"), extractedData };
+}
+
+function getOutputValue(output: unknown): unknown {
+  if (typeof output !== "object" || output === null) return output;
+  const o = output as Record<string, unknown>;
+  // { type: "json", value: {...} } or { type: "content", value: [...] }
+  if ("value" in o) {
+    const v = o.value;
+    // content arrays: [{type:"text", text:"..."}]
+    if (Array.isArray(v)) {
+      const texts = v
+        .filter((c: any) => c?.type === "text" && typeof c?.text === "string")
+        .map((c: any) => c.text)
+        .join(" ");
+      return texts || v;
+    }
+    return v;
+  }
+  return o;
+}
+
+/** Pull structured data out of an extract tool output */
+function extractStructured(output: unknown): unknown {
+  if (output == null) return null;
+  const val = getOutputValue(output);
+  if (typeof val !== "object" || val === null) return val;
+  const v = val as Record<string, unknown>;
+  if (v.success && v.result != null) {
+    const r = v.result as Record<string, unknown>;
+    return r.extraction ?? r;
+  }
+  if (v.extraction != null) return v.extraction;
+  if (v.result != null) return v.result;
+  return val;
+}
+
+/**
+ * Executes a browser task using Stagehand's agent() function.
+ * The agent autonomously navigates, clicks, types, and extracts data
+ * based on the plan's goal — no manual step-by-step execution.
+ */
+export async function executeBrowserPlan(
+  plan: BrowserPlan,
+  previousFeedback?: string
+): Promise<ExecutionResult[]> {
+  let stagehand: InstanceType<typeof Stagehand>;
+  try {
+    stagehand = getStagehandClient();
+    await stagehand.init();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const hint = msg.toLowerCase().includes("executable")
+      ? " Make sure Brave browser is installed at the configured path in executor.ts."
+      : msg.toLowerCase().includes("connect") || msg.toLowerCase().includes("timeout")
+      ? " Check that no other browser instance is blocking port 9222."
+      : "";
+    return [{
+      success: false,
+      error: `Browser failed to start: ${msg}${hint}`,
+      message: "Browser initialization failed",
+      stepNumber: 1,
+      action: "agent",
+    }];
+  }
+
+  // Build the instruction from the plan goal + feedback context
+  const instruction = previousFeedback
+    ? `${plan.goal}\n\nPrevious attempt feedback to address: ${previousFeedback}`
+    : plan.goal;
+
+  const systemPrompt = `You are a browser automation agent.
+
+Rules:
+- Execute the task efficiently and completely.
+- Avoid unnecessary navigation.
+- Extract all requested structured data.
+- Stop only when the task is fully complete.
+- Extract details in deep provide complete comprehensive details about the topic then call it done
+
+Before calling done:
+1. Re-read the original user request.
+2. Verify every requested piece of information is collected.
+3. If anything is missing, continue browsing.
+4. Only call done when all requirements are satisfied.
+
+User asks:
+"Get top 5 jobs and detailed descriptions."
+
+Required:
+✓ 5 jobs found
+✓ description for job 1
+✓ description for job 2
+✓ description for job 3
+✓ description for job 4
+✓ description for job 5
+
+Only call done when all 6 checks pass.
+`;
+
+  // Ensure downloads folder exists
+  if (!existsSync(DOWNLOADS_PATH)) mkdirSync(DOWNLOADS_PATH, { recursive: true });
+
+  // Use CDP to intercept downloads — may not be available on all setups
+  const conn = (stagehand.context as any)?.conn;
+  const downloadedFiles: string[] = [];
+
+  if (conn && typeof conn.send === "function") {
+    try {
+      await conn.send("Browser.setDownloadBehavior", {
+        behavior: "allow",
+        downloadPath: DOWNLOADS_PATH,
+        eventsEnabled: true,
+      });
+
+      const pendingDownloads = new Map<string, string>();
+      conn.on("Browser.downloadWillBegin", (params: any) => {
+        const filename = params.suggestedFilename || `download-${params.guid}`;
+        const savePath = resolve(DOWNLOADS_PATH, filename);
+        pendingDownloads.set(params.guid, savePath);
+        console.log(`[download] starting → ${savePath}`);
+      });
+
+      conn.on("Browser.downloadProgress", (params: any) => {
+        if (params.state === "completed") {
+          const savePath = pendingDownloads.get(params.guid);
+          if (savePath) {
+            downloadedFiles.push(savePath);
+            pendingDownloads.delete(params.guid);
+            console.log(`[download] saved → ${savePath}`);
+          }
+        } else if (params.state === "canceled") {
+          pendingDownloads.delete(params.guid);
+        }
+      });
+    } catch {
+      // CDP download tracking unavailable — continue without it
+    }
+  }
+
+  try {
+    const agent = stagehand.agent({
+      mode: "dom",
+      systemPrompt,
+    });
+
+    const res = await agent.execute({
+      instruction,
+      maxSteps: 10,
+      highlightCursor: true,
+    });
+
+    const messages = res.messages ?? [];
+    const { transcript, extractedData } = parseAgentMessages(messages);
+    const completed = res.completed ?? false;
+
+    // Capture any top-level text stagehand puts on the response object
+    const topLevelText = [
+      (res as any).output,
+      (res as any).result,
+      (res as any).message,
+      (res as any).text,
+    ]
+      .filter((v) => typeof v === "string" && v.trim().length > 0)
+      .join("\n");
+
+    const agentOutput = transcript || topLevelText;
+
+    return [
+      {
+        success: completed,
+        message: completed
+          ? "Agent completed the task successfully"
+          : "Agent did not complete the task",
+        stepNumber: 1,
+        action: "agent",
+        agentOutput,
+        agentMessages: messages,
+        data:
+          extractedData ??
+          (topLevelText ? { output: topLevelText } : undefined),
+        ...(downloadedFiles.length > 0 && { downloadedFiles }),
+      },
+    ];
+  } catch (error) {
+    return [
+      {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        message: "Agent execution failed",
+        stepNumber: 1,
+        action: "agent",
+      },
+    ];
+  }
+}
+
+export async function closeStagehand(): Promise<void> {
+  if (globalStagehand) {
+    await globalStagehand.close();
+    globalStagehand = null;
+  }
+}

package/plan/browser-agent/index.ts

@@ -0,0 +1,13 @@
+export { runBrowserAgentMode } from './orchestrator';
+export type {
+  BrowserPlan,
+  BrowserStep,
+  ExecutionResult,
+  IterationResult,
+  EvaluationResult,
+  BrowserAgentConfig,
+  BrowserAgentResult,
+} from './types';
+export { generateBrowserPlan } from './planner';
+export { executeBrowserPlan, closeStagehand } from './executor';
+export { evaluateExecutionResults, shouldContinueIterating } from './evaluator';

package/plan/browser-agent/orchestrator.ts

@@ -0,0 +1,323 @@
+import chalk from "chalk";
+import { text, confirm } from "@clack/prompts";
+import { withSpinner } from "../../tui/spinner";
+import { renderHTMLMarkdown } from "../../tui/terminal-render.ts";
+import { generateBrowserPlan } from "./planner";
+import { executeBrowserPlan, closeStagehand } from "./executor";
+import {
+  evaluateExecutionResults,
+  extractFeedbackForNextIteration,
+} from "./evaluator";
+import { sendMail } from "../../email_ops/email_functions";
+import type {
+  BrowserAgentResult,
+  IterationResult,
+  BrowserAgentConfig,
+} from "./types";
+import { printLLMError } from "../../utils/llm-error";
+
+const DEFAULT_CONFIG: BrowserAgentConfig = {
+  maxIterations: 5,
+  timeout: 120000,
+  model: "google/gemini-3.1-flash-lite-preview",
+  apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY || "",
+  evaluationThreshold: 80,
+};
+
+export async function runBrowserAgentMode(): Promise<void> {
+  console.log(chalk.bold("\n🌐 Browser Agent Mode\n"));
+
+  const queryInput = await text({
+    message: "What would you like the browser agent to do?",
+    placeholder: "e.g., Find top 5 AI jobs and get their descriptions...",
+  });
+
+  const query = typeof queryInput === "string" ? queryInput : "";
+
+  if (!query || query.trim() === "") {
+    console.log(chalk.yellow("\nOperation cancelled.\n"));
+    return;
+  }
+
+  const liveOutput = await confirm({
+    message: "Show live iteration output?",
+    initialValue: false,
+  });
+
+  const maybeLog = (...args: any[]) => {
+    if (liveOutput) console.log(...args);
+  };
+
+  const config = { ...DEFAULT_CONFIG };
+  const iterations: IterationResult[] = [];
+  let iteration = 0;
+  let previousFeedback: string | undefined;
+  let finalData: unknown = null;
+  let lastEvaluation = null;
+
+  try {
+    while (iteration < config.maxIterations) {
+      iteration++;
+      maybeLog(chalk.bold(`\n📋 Iteration ${iteration}/${config.maxIterations}`));
+
+      // PLAN PHASE
+      let plan;
+      try {
+        plan = await withSpinner(
+          `[${iteration}/${config.maxIterations}] Planning...`,
+          () => generateBrowserPlan(query, previousFeedback)
+        );
+      } catch (error) {
+        printLLMError(error, "Browser planner");
+        break;
+      }
+
+      maybeLog(chalk.dim(`Goal: ${plan.goal}`));
+      maybeLog(chalk.dim(`Reasoning: ${plan.reasoning}`));
+
+      // EXECUTE PHASE — Stagehand agent() runs the task autonomously
+      let execution;
+      try {
+        execution = await withSpinner(
+          `[${iteration}/${config.maxIterations}] Browser agent running...`,
+          () => executeBrowserPlan(plan, previousFeedback)
+        );
+      } catch (error) {
+        console.log(chalk.red(`✖ Browser execution failed: ${error instanceof Error ? error.message : String(error)}`));
+        break;
+      }
+
+      // Collect extracted data from agent
+      for (const result of execution) {
+        if (result.data != null) {
+          finalData = result.data;
+        }
+      }
+
+      const agentResult = execution[0];
+      maybeLog(
+        agentResult?.success
+          ? chalk.green(`✓ Agent completed task`)
+          : chalk.red(`✗ Agent did not complete task`)
+      );
+      if (agentResult?.agentOutput) {
+        maybeLog(chalk.dim(`Output: ${agentResult.agentOutput}`));
+      }
+
+      // EVALUATE PHASE
+      let evaluation;
+      try {
+        evaluation = await withSpinner(
+          `[${iteration}/${config.maxIterations}] Evaluating...`,
+          () => evaluateExecutionResults(query, plan, execution, config.evaluationThreshold)
+        );
+      } catch (error) {
+        printLLMError(error, "Evaluator");
+        break;
+      }
+
+      maybeLog(chalk.cyan(`Score: ${evaluation.score}/100 | Completeness: ${evaluation.completeness}% | Accuracy: ${evaluation.accuracy}%`));
+      maybeLog(chalk.dim(`Feedback: ${evaluation.feedback}`));
+
+      lastEvaluation = evaluation;
+
+      iterations.push({
+        iteration,
+        plan,
+        execution,
+        evaluation,
+        shouldContinue: !evaluation.satisfied && iteration < config.maxIterations,
+      });
+
+      if (evaluation.satisfied) {
+        maybeLog(chalk.green.bold(`\n✓ Task satisfied!\n`));
+        break;
+      }
+
+      if (iteration >= config.maxIterations) {
+        maybeLog(chalk.yellow(`\n⚠ Max iterations reached.\n`));
+        break;
+      }
+
+      previousFeedback = extractFeedbackForNextIteration(evaluation);
+      maybeLog(chalk.yellow(`Retrying with feedback...`));
+    }
+
+    // BUILD CONSOLIDATED RESULT
+    const result: BrowserAgentResult = {
+      success: lastEvaluation?.satisfied || false,
+      query,
+      finalData,
+      iterations,
+      totalIterations: iteration,
+      completedAt: new Date().toISOString(),
+      error: lastEvaluation?.satisfied ? undefined : "Max iterations reached without full satisfaction",
+    };
+
+    // CONSOLIDATED OUTPUT
+    console.log(chalk.bold("\n═══════════════════════════════════════════"));
+    console.log(chalk.bold("📊 Browser Agent Result"));
+    console.log(chalk.bold("═══════════════════════════════════════════\n"));
+
+    console.log(`Query:      ${chalk.cyan(query)}`);
+    console.log(`Status:     ${result.success ? chalk.green("✓ Succeeded") : chalk.yellow("⚠ Partial")}`);
+    console.log(`Iterations: ${iteration}/${config.maxIterations}`);
+
+    if (lastEvaluation) {
+      console.log(`Score:      ${chalk.cyan(`${lastEvaluation.score}/100`)}`);
+      console.log(`Complete:   ${chalk.cyan(`${lastEvaluation.completeness}%`)}`);
+    }
+
+    // Show final agent output if available
+    const lastExecution = iterations[iterations.length - 1]?.execution[0];
+    if (lastExecution?.agentOutput) {
+      console.log(chalk.bold("\n🤖 Agent Output:"));
+      console.log(chalk.white(lastExecution.agentOutput));
+    }
+
+    if (finalData) {
+      console.log(chalk.bold("\n📦 Extracted Data:"));
+      console.log(chalk.dim(JSON.stringify(finalData, null, 2)));
+    }
+
+    if (lastEvaluation?.feedback) {
+      console.log(chalk.bold("\n💬 Final Feedback:"));
+      console.log(chalk.dim(lastEvaluation.feedback));
+    }
+
+    console.log(chalk.bold("\n═══════════════════════════════════════════\n"));
+
+    // Render markdown report
+    const reportMarkdown = buildBrowserAgentMarkdownReport(result);
+    console.log(chalk.bold("📄 Report\n"));
+    console.log(renderHTMLMarkdown(reportMarkdown));
+    console.log(chalk.bold("\n═══════════════════════════════════════════\n"));
+
+    // Save options
+    const shouldSaveJson = await confirm({
+      message: "Save results to JSON file?",
+      initialValue: false,
+    });
+
+    if (shouldSaveJson) {
+      const fs = await import("fs");
+      const path = await import("path");
+      const filename = `browser-agent-result-${Date.now()}.json`;
+      const filepath = path.resolve(process.cwd(), filename);
+      fs.writeFileSync(filepath, JSON.stringify(result, null, 2), "utf8");
+      console.log(chalk.green(`✓ Saved to ${filename}\n`));
+    }
+
+    const shouldSaveMd = await confirm({
+      message: "Save Markdown report to file?",
+      initialValue: false,
+    });
+
+    if (shouldSaveMd) {
+      const fs = await import("fs");
+      const path = await import("path");
+      const filename = `browser-agent-report-${Date.now()}.md`;
+      const filepath = path.resolve(process.cwd(), filename);
+      fs.writeFileSync(filepath, reportMarkdown, "utf8");
+      console.log(chalk.green(`✓ Saved to ${filename}\n`));
+    }
+
+    // ── Email option ──────────────────────────────────────────────────
+    const shouldEmail = await confirm({
+      message: "Send a summary to your email?",
+      initialValue: false,
+    });
+
+    if (shouldEmail) {
+      const emailTo = await text({ message: "Send to (email address)?" });
+      if (typeof emailTo === "string" && emailTo.trim()) {
+        // Build a concise email body from the agent output + score
+        const agentOut = lastExecution?.agentOutput ?? "";
+        const scoreInfo = lastEvaluation
+          ? `Score: ${lastEvaluation.score}/100 | Completeness: ${lastEvaluation.completeness}%`
+          : "";
+        const emailBody = [
+          `Query: ${query}`,
+          scoreInfo,
+          "",
+          agentOut || JSON.stringify(finalData, null, 2) || "(no output)",
+        ]
+          .filter(Boolean)
+          .join("\n");
+
+        await withSpinner("Sending email…", () =>
+          sendMail({
+            to: emailTo.trim(),
+            subject: `Browser Agent: ${query.slice(0, 60)}`,
+            body: emailBody,
+          })
+        );
+        console.log(chalk.green("✓ Email sent\n"));
+      }
+    }
+  } catch (error) {
+    printLLMError(error, "Browser Agent");
+  } finally {
+    try {
+      await closeStagehand();
+    } catch (err) {
+      console.error("Error closing browser:", err);
+    }
+  }
+}
+
+function buildBrowserAgentMarkdownReport(result: BrowserAgentResult): string {
+  const lines: string[] = [];
+
+  lines.push("# Browser Agent Report\n");
+  lines.push(`**Query:** ${result.query}`);
+  lines.push(`**Status:** ${result.success ? "✅ Succeeded" : "⚠️ Partial"}`);
+  lines.push(`**Total Iterations:** ${result.totalIterations}`);
+  lines.push(`**Completed At:** ${result.completedAt}`);
+  if (result.error) {
+    lines.push(`**Note:** ${result.error}`);
+  }
+  lines.push("");
+
+  // Only show the last (best) iteration's detail in consolidated mode
+  const lastIteration = result.iterations[result.iterations.length - 1];
+  if (lastIteration) {
+    lines.push("## Final Iteration Result\n");
+
+    const agentResult = lastIteration.execution[0];
+    if (agentResult?.agentOutput) {
+      lines.push("### Agent Output");
+      lines.push(agentResult.agentOutput);
+      lines.push("");
+    }
+
+    lines.push("### Evaluation");
+    lines.push(`- **Score:** ${lastIteration.evaluation.score}/100`);
+    lines.push(`- **Completeness:** ${lastIteration.evaluation.completeness}%`);
+    lines.push(`- **Accuracy:** ${lastIteration.evaluation.accuracy}%`);
+    lines.push(`- **Feedback:** ${lastIteration.evaluation.feedback}`);
+    if (lastIteration.evaluation.issues.length > 0) {
+      lines.push("- **Issues:**");
+      lastIteration.evaluation.issues.forEach((issue) => {
+        lines.push(`  - ${issue}`);
+      });
+    }
+    lines.push("");
+  }
+
+  lines.push("## Extracted Data\n");
+  lines.push("```json");
+  lines.push(JSON.stringify(result.finalData ?? {}, null, 2));
+  lines.push("```\n");
+
+  if (result.iterations.length > 1) {
+    lines.push("## Iteration Summary\n");
+    result.iterations.forEach((it) => {
+      lines.push(`- Iteration ${it.iteration}: Score ${it.evaluation.score}/100 — ${it.evaluation.satisfied ? "✅ Satisfied" : "🔄 Continued"}`);
+    });
+    lines.push("");
+  }
+
+  lines.push("*Generated by Browser Agent*");
+  return lines.join("\n");
+}