@mindstudio-ai/remy 0.1.8 → 0.1.10

package/dist/headless.js

@@ -1,7 +1,7 @@
 // src/headless.ts
 import { createInterface } from "readline";
-import fs15 from "fs";
-import path8 from "path";
+import fs16 from "fs";
+import path9 from "path";
 
 // src/config.ts
 import fs2 from "fs";
@@ -194,11 +194,14 @@ function loadSpecFileMetadata() {
     }
     const entries = [];
     for (const filePath of files) {
-      const { name, description } = parseFrontmatter(filePath);
+      const { name, description, type } = parseFrontmatter(filePath);
       let line = `- ${filePath}`;
       if (name) {
         line += ` \u2014 "${name}"`;
       }
+      if (type) {
+        line += ` (${type})`;
+      }
       if (description) {
         line += ` \u2014 ${description}`;
       }
@@ -232,14 +235,15 @@ function parseFrontmatter(filePath) {
     const content = fs3.readFileSync(filePath, "utf-8");
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) {
-      return { name: "", description: "" };
+      return { name: "", description: "", type: "" };
     }
     const fm = match[1];
     const name = fm.match(/^name:\s*(.+)$/m)?.[1]?.trim() ?? "";
     const description = fm.match(/^description:\s*(.+)$/m)?.[1]?.trim() ?? "";
-    return { name, description };
+    const type = fm.match(/^type:\s*(.+)$/m)?.[1]?.trim() ?? "";
+    return { name, description, type };
   } catch {
-    return { name: "", description: "" };
+    return { name: "", description: "", type: "" };
   }
 }
 function loadProjectFileListing() {
@@ -448,11 +452,35 @@ async function* streamChat(params) {
     yield { type: "error", error: errorMessage };
     return;
   }
+  const STALL_TIMEOUT_MS = 3e5;
   const reader = res.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
   while (true) {
-    const { done, value } = await reader.read();
+    let stallTimer;
+    let readResult;
+    try {
+      readResult = await Promise.race([
+        reader.read(),
+        new Promise((_, reject) => {
+          stallTimer = setTimeout(
+            () => reject(new Error("stream_stall")),
+            STALL_TIMEOUT_MS
+          );
+        })
+      ]);
+      clearTimeout(stallTimer);
+    } catch {
+      clearTimeout(stallTimer);
+      await reader.cancel();
+      log.error("Stream stalled", { elapsed: `${Date.now() - startTime}ms` });
+      yield {
+        type: "error",
+        error: "Stream stalled \u2014 no data received for 5 minutes"
+      };
+      return;
+    }
+    const { done, value } = readResult;
     if (done) {
       break;
     }
@@ -486,6 +514,50 @@ async function* streamChat(params) {
     }
   }
 }
+var MAX_RETRIES = 3;
+var INITIAL_BACKOFF_MS = 1e3;
+function isRetryableError(error) {
+  return /Network error/i.test(error) || /HTTP 5\d\d/i.test(error) || /Stream stalled/i.test(error);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function* streamChatWithRetry(params, options) {
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    const buffer = [];
+    let retryableFailure = false;
+    for await (const event of streamChat(params)) {
+      if (event.type === "error") {
+        if (isRetryableError(event.error) && attempt < MAX_RETRIES - 1) {
+          log.warn("Retryable error, will retry", {
+            attempt: attempt + 1,
+            maxRetries: MAX_RETRIES,
+            error: event.error
+          });
+          options?.onRetry?.(attempt, event.error);
+          retryableFailure = true;
+          break;
+        }
+        yield event;
+        return;
+      }
+      buffer.push(event);
+    }
+    if (retryableFailure) {
+      if (params.signal?.aborted) {
+        return;
+      }
+      const backoff = INITIAL_BACKOFF_MS * 2 ** attempt;
+      log.info("Retrying after backoff", { backoffMs: backoff });
+      await sleep(backoff);
+      continue;
+    }
+    for (const event of buffer) {
+      yield event;
+    }
+    return;
+  }
+}
 
 // src/tools/spec/readSpec.ts
 import fs5 from "fs/promises";
@@ -893,7 +965,88 @@ async function listRecursive(dir) {
   return results;
 }
 
-// src/tools/spec/setProjectOnboardingState.ts
+// src/tools/spec/clearSyncStatus.ts
+var clearSyncStatusTool = {
+  definition: {
+    name: "clearSyncStatus",
+    description: "Clear the sync status flags after syncing spec and code. Call this after finishing a sync operation.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  async execute() {
+    return "ok";
+  }
+};
+
+// src/tools/spec/presentSyncPlan.ts
+var presentSyncPlanTool = {
+  definition: {
+    name: "presentSyncPlan",
+    description: "Present a structured sync plan to the user for approval. Write a clear markdown summary of what changed and what you intend to update. The user will see this in a full-screen view and can approve or dismiss. Call this BEFORE making any sync edits.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "Markdown plan describing what changed and what will be updated."
+        }
+      },
+      required: ["content"]
+    }
+  },
+  streaming: {},
+  async execute() {
+    return "approved";
+  }
+};
+
+// src/tools/spec/presentPublishPlan.ts
+var presentPublishPlanTool = {
+  definition: {
+    name: "presentPublishPlan",
+    description: "Present a publish changelog to the user for approval. Write a clear markdown summary of what changed since the last deploy. The user will see this in a full-screen view and can approve or dismiss. Call this BEFORE committing or pushing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "Markdown changelog describing what changed and what will be deployed."
+        }
+      },
+      required: ["content"]
+    }
+  },
+  streaming: {},
+  async execute() {
+    return "approved";
+  }
+};
+
+// src/tools/spec/presentPlan.ts
+var presentPlanTool = {
+  definition: {
+    name: "presentPlan",
+    description: "Present an implementation plan for user approval before making changes. Use this only for large, multi-step changes or when the user explicitly asks to see a plan. Most work should be done autonomously without a plan. Write a clear markdown summary of what you intend to do in plain language \u2014 describe the changes from the user's perspective, not as a list of files and code paths. If the user rejects with feedback, revise and present again.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "Markdown plan describing what you intend to do."
+        }
+      },
+      required: ["content"]
+    }
+  },
+  streaming: {},
+  async execute() {
+    return "approved";
+  }
+};
+
+// src/tools/common/setProjectOnboardingState.ts
 var setProjectOnboardingStateTool = {
   definition: {
     name: "setProjectOnboardingState",
@@ -919,7 +1072,7 @@ var setProjectOnboardingStateTool = {
   }
 };
 
-// src/tools/spec/promptUser.ts
+// src/tools/common/promptUser.ts
 var promptUserTool = {
   definition: {
     name: "promptUser",
@@ -947,8 +1100,8 @@ var promptUserTool = {
               },
               type: {
                 type: "string",
-                enum: ["select", "checklist", "text", "file", "color"],
-                description: "select: pick one from a list. checklist: pick one or more from a list. text: free-form input. file: file/image upload, returns CDN URL(s) that can be referenced directly or curled onto disk. color: color picker (returns hex)."
+                enum: ["select", "checklist", "text", "file"],
+                description: 'select: pick one from a list. checklist: pick one or more from a list. The user can always provide a custom "Other" answer for select and checklist questions, so there is no need to include an "Other" option. text: free-form input. file: file/image upload, returns CDN URL(s) that can be referenced directly or curled onto disk.'
               },
               helpText: {
                 type: "string",
@@ -985,10 +1138,6 @@ var promptUserTool = {
                 type: "boolean",
                 description: "For file type: allow multiple uploads (returns array of URLs). Defaults to false."
               },
-              allowOther: {
-                type: "boolean",
-                description: 'For select and checklist types: adds an "Other" option that lets the user type a custom answer. Use this instead of adding a separate follow-up text field for custom input. Defaults to false.'
-              },
               format: {
                 type: "string",
                 enum: ["email", "url", "phone", "number"],
@@ -1046,8 +1195,6 @@ var promptUserTool = {
         line += q.type === "checklist" ? ` (pick one or more: ${opts.join(" / ")})` : ` (${opts.join(" / ")})`;
       } else if (q.type === "file") {
         line += " (upload file)";
-      } else if (q.type === "color") {
-        line += " (pick a color)";
       }
       return line;
     });
@@ -1056,113 +1203,181 @@ ${lines.join("\n")}`;
   }
 };
 
-// src/tools/spec/clearSyncStatus.ts
-var clearSyncStatusTool = {
+// src/tools/common/confirmDestructiveAction.ts
+var confirmDestructiveActionTool = {
   definition: {
-    name: "clearSyncStatus",
-    description: "Clear the sync status flags after syncing spec and code. Call this after finishing a sync operation.",
+    name: "confirmDestructiveAction",
+    description: "Confirm a destructive or irreversible action with the user. Use for things like deleting data, resetting the database, or discarding draft work. Do not use after presentSyncPlan, presentPublishPlan, or presentPlan (those already include approval). Do not use before onboarding state transitions.",
     inputSchema: {
       type: "object",
-      properties: {}
+      properties: {
+        message: {
+          type: "string",
+          description: "Explanation of what is about to happen and why confirmation is needed."
+        },
+        confirmLabel: {
+          type: "string",
+          description: 'Custom label for the confirm button (e.g., "Delete", "Reset Database"). Defaults to "Confirm".'
+        },
+        dismissLabel: {
+          type: "string",
+          description: 'Custom label for the dismiss button (e.g., "Keep It", "Go Back"). Defaults to "Cancel".'
+        }
+      },
+      required: ["message"]
     }
   },
   async execute() {
-    return "ok";
+    return "confirmed";
   }
 };
 
-// src/tools/spec/presentSyncPlan.ts
-var presentSyncPlanTool = {
+// src/tools/common/askMindStudioSdk.ts
+import { exec } from "child_process";
+var askMindStudioSdkTool = {
   definition: {
-    name: "presentSyncPlan",
-    description: "Present a structured sync plan to the user for approval. Write a clear markdown summary of what changed and what you intend to update. The user will see this in a full-screen view and can approve or dismiss. Call this BEFORE making any sync edits.",
+    name: "askMindStudioSdk",
+    description: "Ask the MindStudio SDK assistant about available actions, AI models, connectors, and integrations using natural language. Returns code examples with correct method signatures, model IDs, and config options. Always use this to verify correct SDK usage, especially model IDs and configuration options. Describe what you need, not what API methods you need; the assistant will figure out the right approach. This runs its own LLM call so it has a few seconds of latency; batch multiple questions into a single query.",
     inputSchema: {
       type: "object",
       properties: {
-        content: {
+        query: {
           type: "string",
-          description: "Markdown plan describing what changed and what will be updated."
+          description: "Natural language question about the SDK."
         }
       },
-      required: ["content"]
+      required: ["query"]
     }
   },
-  streaming: {},
-  async execute() {
-    return "approved";
+  async execute(input) {
+    const query = input.query;
+    return new Promise((resolve) => {
+      exec(
+        `mindstudio ask ${JSON.stringify(query)}`,
+        { timeout: 6e4, maxBuffer: 512 * 1024 },
+        (err, stdout, stderr) => {
+          if (stdout.trim()) {
+            resolve(stdout.trim());
+            return;
+          }
+          if (err) {
+            resolve(`Error: ${stderr.trim() || err.message}`);
+            return;
+          }
+          resolve("(no response)");
+        }
+      );
+    });
   }
 };
 
-// src/tools/spec/presentPublishPlan.ts
-var presentPublishPlanTool = {
+// src/tools/common/fetchUrl.ts
+import { exec as exec2 } from "child_process";
+var fetchUrlTool = {
   definition: {
-    name: "presentPublishPlan",
-    description: "Present a publish changelog to the user for approval. Write a clear markdown summary of what changed since the last deploy. The user will see this in a full-screen view and can approve or dismiss. Call this BEFORE committing or pushing.",
+    name: "scapeWebUrl",
+    description: "Scrape the content of a web page. Returns the HTML of the page as markdown text. Optionally capture a screenshot if you need see the visual design. Use this when you need to fetch or analyze content from a website",
     inputSchema: {
       type: "object",
       properties: {
-        content: {
+        url: {
           type: "string",
-          description: "Markdown changelog describing what changed and what will be deployed."
+          description: "The URL to fetch."
+        },
+        screenshot: {
+          type: "boolean",
+          description: "Capture a screenshot of the page in addition to the text content. Adds latency; only use when you need to see the visual design."
         }
       },
-      required: ["content"]
+      required: ["url"]
     }
   },
-  streaming: {},
-  async execute() {
-    return "approved";
+  async execute(input) {
+    const url = input.url;
+    const screenshot = input.screenshot;
+    const pageOptions = { onlyMainContent: true };
+    if (screenshot) {
+      pageOptions.screenshot = true;
+    }
+    const cmd = `mindstudio scrape-url --url ${JSON.stringify(url)} --page-options ${JSON.stringify(JSON.stringify(pageOptions))} --no-meta`;
+    return new Promise((resolve) => {
+      exec2(
+        cmd,
+        { timeout: 6e4, maxBuffer: 1024 * 1024 },
+        (err, stdout, stderr) => {
+          if (stdout.trim()) {
+            resolve(stdout.trim());
+            return;
+          }
+          if (err) {
+            resolve(`Error: ${stderr.trim() || err.message}`);
+            return;
+          }
+          resolve("(no response)");
+        }
+      );
+    });
   }
 };
 
-// src/tools/spec/presentPlan.ts
-var presentPlanTool = {
+// src/tools/common/searchGoogle.ts
+import { exec as exec3 } from "child_process";
+var searchGoogleTool = {
   definition: {
-    name: "presentPlan",
-    description: "Present an implementation plan for user approval before making changes. Use this only for large, multi-step changes or when the user explicitly asks to see a plan. Most work should be done autonomously without a plan. Write a clear markdown summary of what you intend to do in plain language \u2014 describe the changes from the user's perspective, not as a list of files and code paths. If the user rejects with feedback, revise and present again.",
+    name: "searchGoogle",
+    description: "Search Google and return results. Use for research, finding documentation, looking up APIs, or any task where web search would help.",
     inputSchema: {
       type: "object",
       properties: {
-        content: {
+        query: {
           type: "string",
-          description: "Markdown plan describing what you intend to do."
+          description: "The search query."
         }
       },
-      required: ["content"]
+      required: ["query"]
     }
   },
-  streaming: {},
-  async execute() {
-    return "approved";
+  async execute(input) {
+    const query = input.query;
+    const cmd = `mindstudio search-google --query ${JSON.stringify(query)} --export-type json --output-key results --no-meta`;
+    return new Promise((resolve) => {
+      exec3(
+        cmd,
+        { timeout: 6e4, maxBuffer: 512 * 1024 },
+        (err, stdout, stderr) => {
+          if (stdout.trim()) {
+            resolve(stdout.trim());
+            return;
+          }
+          if (err) {
+            resolve(`Error: ${stderr.trim() || err.message}`);
+            return;
+          }
+          resolve("(no response)");
+        }
+      );
+    });
   }
 };
 
-// src/tools/spec/confirmDestructiveAction.ts
-var confirmDestructiveActionTool = {
+// src/tools/common/setProjectName.ts
+var setProjectNameTool = {
   definition: {
-    name: "confirmDestructiveAction",
-    description: "Confirm a destructive or irreversible action with the user. Use for things like deleting data, resetting the database, or discarding draft work. Do not use after presentSyncPlan, presentPublishPlan, or presentPlan (those already include approval). Do not use before onboarding state transitions.",
+    name: "setProjectName",
+    description: `Set the project display name. Call this after intake once you have enough context to give the project a clear, descriptive name. Keep it short (2-4 words). Use the app's actual name if the user mentioned one, otherwise pick something descriptive ("Vendor Procurement App", "Recipe Manager").`,
     inputSchema: {
       type: "object",
       properties: {
-        message: {
-          type: "string",
-          description: "Explanation of what is about to happen and why confirmation is needed."
-        },
-        confirmLabel: {
-          type: "string",
-          description: 'Custom label for the confirm button (e.g., "Delete", "Reset Database"). Defaults to "Confirm".'
-        },
-        dismissLabel: {
+        name: {
           type: "string",
-          description: 'Custom label for the dismiss button (e.g., "Keep It", "Go Back"). Defaults to "Cancel".'
+          description: "The project name."
         }
       },
-      required: ["message"]
+      required: ["name"]
     }
   },
   async execute() {
-    return "confirmed";
+    return "ok";
   }
 };
 
@@ -1170,9 +1385,9 @@ var confirmDestructiveActionTool = {
 import fs9 from "fs/promises";
 var DEFAULT_MAX_LINES2 = 500;
 function isBinary(buffer) {
-  const sample = buffer.subarray(0, 8192);
-  for (let i = 0; i < sample.length; i++) {
-    if (sample[i] === 0) {
+  const sample2 = buffer.subarray(0, 8192);
+  for (let i = 0; i < sample2.length; i++) {
+    if (sample2[i] === 0) {
       return true;
     }
   }
@@ -1466,7 +1681,7 @@ ${unifiedDiff(input.path, content, updated)}`;
 };
 
 // src/tools/code/bash.ts
-import { exec } from "child_process";
+import { exec as exec4 } from "child_process";
 var DEFAULT_TIMEOUT_MS = 12e4;
 var DEFAULT_MAX_LINES3 = 500;
 var bashTool = {
@@ -1500,7 +1715,7 @@ var bashTool = {
     const maxLines = input.maxLines === 0 ? Infinity : input.maxLines || DEFAULT_MAX_LINES3;
     const timeoutMs = input.timeout ? input.timeout * 1e3 : DEFAULT_TIMEOUT_MS;
     return new Promise((resolve) => {
-      exec(
+      exec4(
         input.command,
         {
           timeout: timeoutMs,
@@ -1540,7 +1755,7 @@ var bashTool = {
 };
 
 // src/tools/code/grep.ts
-import { exec as exec2 } from "child_process";
+import { exec as exec5 } from "child_process";
 var DEFAULT_MAX = 50;
 function formatResults(stdout, max) {
   const lines = stdout.trim().split("\n");
@@ -1587,12 +1802,12 @@ var grepTool = {
     const rgCmd = `rg -n --no-heading --max-count=${max}${globFlag} '${escaped}' ${searchPath}`;
     const grepCmd = `grep -rn --max-count=${max} '${escaped}' ${searchPath} --include='*.ts' --include='*.tsx' --include='*.js' --include='*.json' --include='*.md'`;
     return new Promise((resolve) => {
-      exec2(rgCmd, { maxBuffer: 512 * 1024 }, (err, stdout) => {
+      exec5(rgCmd, { maxBuffer: 512 * 1024 }, (err, stdout) => {
         if (stdout?.trim()) {
           resolve(formatResults(stdout, max));
           return;
         }
-        exec2(grepCmd, { maxBuffer: 512 * 1024 }, (_err, grepStdout) => {
+        exec5(grepCmd, { maxBuffer: 512 * 1024 }, (_err, grepStdout) => {
           if (grepStdout?.trim()) {
             resolve(formatResults(grepStdout, max));
           } else {
@@ -1776,47 +1991,8 @@ var restartProcessTool = {
   }
 };
 
-// src/tools/code/askMindStudioSdk.ts
-import { exec as exec3 } from "child_process";
-var askMindStudioSdkTool = {
-  definition: {
-    name: "askMindStudioSdk",
-    description: "Ask the MindStudio SDK assistant about available actions, AI models, connectors, and integrations using natural language. Returns code examples with correct method signatures, model IDs, and config options. Always use this to verify correct SDK usage, especially model IDs and configuration options. Describe what you need, not what API methods you need; the assistant will figure out the right approach. This runs its own LLM call so it has a few seconds of latency; batch multiple questions into a single query.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: "Natural language question about the SDK."
-        }
-      },
-      required: ["query"]
-    }
-  },
-  async execute(input) {
-    const query = input.query;
-    return new Promise((resolve) => {
-      exec3(
-        `mindstudio ask ${JSON.stringify(query)}`,
-        { timeout: 6e4, maxBuffer: 512 * 1024 },
-        (err, stdout, stderr) => {
-          if (stdout.trim()) {
-            resolve(stdout.trim());
-            return;
-          }
-          if (err) {
-            resolve(`Error: ${stderr.trim() || err.message}`);
-            return;
-          }
-          resolve("(no response)");
-        }
-      );
-    });
-  }
-};
-
-// src/tools/code/runScenario.ts
-var runScenarioTool = {
+// src/tools/code/runScenario.ts
+var runScenarioTool = {
   definition: {
     name: "runScenario",
     description: "Run a scenario to seed the dev database with test data. Truncates all tables first, then executes the seed function and impersonates the scenario roles. Blocks until complete. Scenario IDs are defined in mindstudio.json. If it fails, check .logs/tunnel.log or .logs/requests.ndjson for details.",
@@ -1903,7 +2079,7 @@ async function runSubAgent(config) {
     const toolCalls = [];
     let stopReason = "end_turn";
     try {
-      for await (const event of streamChat({
+      for await (const event of streamChatWithRetry({
         ...apiConfig,
         model,
         system,
@@ -2121,6 +2297,419 @@ var browserAutomationTool = {
   }
 };
 
+// src/subagents/designExpert/tools.ts
+import { exec as exec6 } from "child_process";
+var DESIGN_REFERENCE_PROMPT = `Analyze this website/app screenshot as a design reference. Assess:
+1) Mood/aesthetic
+2) Color palette with approximate hex values and palette strategy
+3) Typography style
+4) Layout composition (symmetric/asymmetric, grid structure, whitespace usage, content density)
+5) What makes it distinctive and interesting vs generic AI-generated interfaces
+Be specific and concise.`;
+var DESIGN_RESEARCH_TOOLS = [
+  {
+    name: "searchGoogle",
+    description: "Search Google for web results. Use for finding design inspiration, font recommendations, UI patterns, real products in a domain, and reference material.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query."
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "fetchUrl",
+    description: "Fetch the content of a web page as markdown. Optionally capture a screenshot to see the visual design. Use to analyze reference sites, read font specimen pages, or extract design details.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch."
+        },
+        screenshot: {
+          type: "boolean",
+          description: "Capture a screenshot of the page. Use when you need to see the visual design, not just the text."
+        }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "analyzeImage",
+    description: 'Analyze an image using a vision model with a custom prompt. Use when you have a specific question about an image (e.g., "what colors dominate this image?", "describe the typography choices").',
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: {
+          type: "string",
+          description: "What to analyze or extract from the image."
+        },
+        imageUrl: {
+          type: "string",
+          description: "URL of the image to analyze."
+        }
+      },
+      required: ["prompt", "imageUrl"]
+    }
+  },
+  {
+    name: "analyzeDesignReference",
+    description: "Analyze a screenshot or design image for design inspiration. Returns a structured analysis: mood/aesthetic, color palette with hex values, typography style, layout composition, and what makes it distinctive. Use this instead of analyzeImage when studying a design reference.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        imageUrl: {
+          type: "string",
+          description: "URL of the screenshot or design image to analyze."
+        }
+      },
+      required: ["imageUrl"]
+    }
+  },
+  {
+    name: "screenshotAndAnalyze",
+    description: "Screenshot a live URL and analyze it in one step. If no prompt is provided, performs a full design reference analysis (mood, color, typography, layout, distinctiveness). Provide a custom prompt to ask a specific question about the visual design instead.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to screenshot."
+        },
+        prompt: {
+          type: "string",
+          description: "Optional custom analysis prompt. If omitted, performs the standard design reference analysis."
+        }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "searchStockPhotos",
+    description: 'Search Pexels for stock photos. Returns image URLs with descriptions. Use concrete, descriptive queries ("person working at laptop in modern office" not "business").',
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What kind of photo to search for."
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "searchProductScreenshots",
+    description: 'Search for screenshots of real products and apps. Use to find what existing products look like ("stripe dashboard", "linear app", "notion workspace"). Returns image results of actual product UI. Use this for layout and design research on real products, NOT for abstract design inspiration.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        product: {
+          type: "string",
+          description: 'The product or app to find screenshots of (e.g., "stripe dashboard", "figma editor", "mercury banking app").'
+        }
+      },
+      required: ["product"]
+    }
+  },
+  {
+    name: "generateImages",
+    description: "Generate images using AI (Seedream). Returns CDN URLs. Produces high-quality results for both photorealistic images and abstract/creative visuals. Pass multiple prompts to generate in parallel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompts: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "One or more image generation prompts. Be detailed: describe style, mood, composition, colors. Multiple prompts run in parallel."
+        },
+        width: {
+          type: "number",
+          description: "Image width in pixels. Default 2048. Range: 2048-4096."
+        },
+        height: {
+          type: "number",
+          description: "Image height in pixels. Default 2048. Range: 2048-4096."
+        }
+      },
+      required: ["prompts"]
+    }
+  }
+];
+function runCli(cmd) {
+  return new Promise((resolve) => {
+    exec6(
+      cmd,
+      { timeout: 6e4, maxBuffer: 1024 * 1024 },
+      (err, stdout, stderr) => {
+        if (stdout.trim()) {
+          resolve(stdout.trim());
+          return;
+        }
+        if (err) {
+          resolve(`Error: ${stderr.trim() || err.message}`);
+          return;
+        }
+        resolve("(no response)");
+      }
+    );
+  });
+}
+async function executeDesignTool(name, input) {
+  switch (name) {
+    case "searchGoogle":
+      return runCli(
+        `mindstudio search-google --query ${JSON.stringify(input.query)} --export-type json --output-key results --no-meta`
+      );
+    case "fetchUrl": {
+      const pageOptions = { onlyMainContent: true };
+      if (input.screenshot) {
+        pageOptions.screenshot = true;
+      }
+      return runCli(
+        `mindstudio scrape-url --url ${JSON.stringify(input.url)} --page-options ${JSON.stringify(JSON.stringify(pageOptions))} --no-meta`
+      );
+    }
+    case "analyzeImage":
+      return runCli(
+        `mindstudio analyze-image --prompt ${JSON.stringify(input.prompt)} --image-url ${JSON.stringify(input.imageUrl)} --no-meta`
+      );
+    case "analyzeDesignReference":
+      return runCli(
+        `mindstudio analyze-image --prompt ${JSON.stringify(DESIGN_REFERENCE_PROMPT)} --image-url ${JSON.stringify(input.imageUrl)} --no-meta`
+      );
+    case "screenshotAndAnalyze": {
+      const screenshotResult = await runCli(
+        `mindstudio scrape-url --url ${JSON.stringify(input.url)} --page-options ${JSON.stringify(JSON.stringify({ onlyMainContent: true, screenshot: true }))} --no-meta`
+      );
+      const screenshotMatch = screenshotResult.match(
+        /https:\/\/[^\s"']+(?:\.png|\.jpg|\.jpeg|\.webp|screenshot[^\s"']*)/i
+      );
+      if (!screenshotMatch) {
+        try {
+          const parsed = JSON.parse(screenshotResult);
+          const ssUrl = parsed.screenshot || parsed.screenshotUrl || parsed.content?.screenshotUrl;
+          if (ssUrl) {
+            const analysisPrompt2 = input.prompt || DESIGN_REFERENCE_PROMPT;
+            const analysis2 = await runCli(
+              `mindstudio analyze-image --prompt ${JSON.stringify(analysisPrompt2)} --image-url ${JSON.stringify(ssUrl)} --no-meta`
+            );
+            return `Screenshot: ${ssUrl}
+
+${analysis2}`;
+          }
+        } catch {
+        }
+        return `Fetched ${input.url} but could not extract screenshot URL.
+
+Page content:
+${screenshotResult}`;
+      }
+      const analysisPrompt = input.prompt || DESIGN_REFERENCE_PROMPT;
+      const analysis = await runCli(
+        `mindstudio analyze-image --prompt ${JSON.stringify(analysisPrompt)} --image-url ${JSON.stringify(screenshotMatch[0])} --no-meta`
+      );
+      return `Screenshot: ${screenshotMatch[0]}
+
+${analysis}`;
+    }
+    case "searchStockPhotos": {
+      const encodedQuery = encodeURIComponent(input.query);
+      return runCli(
+        `mindstudio scrape-url --url "https://www.pexels.com/search/${encodedQuery}/" --page-options '{"onlyMainContent": true}' --no-meta`
+      );
+    }
+    case "searchProductScreenshots": {
+      const query = `${input.product} product screenshot UI 2026`;
+      return runCli(
+        `mindstudio search-google-images --query ${JSON.stringify(query)} --export-type json --output-key images --no-meta`
+      );
+    }
+    case "generateImages": {
+      const prompts = input.prompts;
+      const width = input.width || 2048;
+      const height = input.height || 2048;
+      if (prompts.length === 1) {
+        const step = JSON.stringify({
+          prompt: prompts[0],
+          imageModelOverride: {
+            model: "seedream-4.5",
+            config: { width, height }
+          }
+        });
+        return runCli(
+          `mindstudio generate-image '${step}' --output-key imageUrl --no-meta`
+        );
+      }
+      const steps = prompts.map((prompt) => ({
+        stepType: "generateImage",
+        step: {
+          prompt,
+          imageModelOverride: {
+            model: "seedream-4.5",
+            config: { width, height }
+          }
+        }
+      }));
+      return runCli(`mindstudio batch '${JSON.stringify(steps)}' --no-meta`);
+    }
+    default:
+      return `Error: unknown tool "${name}"`;
+  }
+}
+
+// src/subagents/designExpert/prompt.ts
+import fs14 from "fs";
+import path8 from "path";
+var base2 = import.meta.dirname ?? path8.dirname(new URL(import.meta.url).pathname);
+function resolvePath(filename) {
+  const local2 = path8.join(base2, filename);
+  return fs14.existsSync(local2) ? local2 : path8.join(base2, "subagents", "designExpert", filename);
+}
+function readFile(filename) {
+  return fs14.readFileSync(resolvePath(filename), "utf-8").trim();
+}
+function readJson(filename, fallback) {
+  try {
+    return JSON.parse(fs14.readFileSync(resolvePath(filename), "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+var RUNTIME_PLACEHOLDERS = /* @__PURE__ */ new Set([
+  "fonts_to_consider",
+  "inspiration_images"
+]);
+var PROMPT_TEMPLATE = readFile("prompt.md").replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+  const k = key.trim();
+  return RUNTIME_PLACEHOLDERS.has(k) ? match : readFile(k);
+}).replace(/\n{3,}/g, "\n\n");
+var fontData = readJson("data/fonts.json", {
+  cssUrlPattern: "",
+  fonts: [],
+  pairings: []
+});
+var inspirationImages = readJson("data/inspiration.json", {
+  images: []
+}).images;
+function sample(arr, n) {
+  if (arr.length <= n) {
+    return [...arr];
+  }
+  const copy = [...arr];
+  for (let i = copy.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [copy[i], copy[j]] = [copy[j], copy[i]];
+  }
+  return copy.slice(0, n);
+}
+function getDesignResearchPrompt() {
+  const fonts = sample(fontData.fonts, 30);
+  const pairings = sample(fontData.pairings, 20);
+  const images = sample(inspirationImages, 40);
+  const fontList = fonts.map((f) => {
+    const tags = f.tags.length ? ` (${f.tags.join(", ")})` : "";
+    let cssInfo = "";
+    if (f.source === "fontshare") {
+      cssInfo = ` CSS: ${fontData.cssUrlPattern.replace("{slug}", f.slug).replace("{weights}", f.weights.join(","))}`;
+    } else if (f.cssUrl) {
+      cssInfo = ` CSS: ${f.cssUrl}`;
+    } else if (f.source === "open-foundry") {
+      cssInfo = " (self-host required)";
+    }
+    return `- **${f.name}** \u2014 ${f.category}${tags}. Weights: ${f.weights.join(", ")}.${f.variable ? " Variable." : ""}${f.italics ? " Has italics." : ""}${cssInfo}`;
+  }).join("\n");
+  const pairingList = pairings.map(
+    (p) => `- **${p.heading.font}** (${p.heading.weight}) heading + **${p.body.font}** (${p.body.weight}) body`
+  ).join("\n");
+  const fontsSection = fonts.length ? `<fonts_to_consider>
+## Fonts to consider
+
+A random sample from Fontshare, Open Foundry, and Google Fonts. Use these as starting points for font selection.
+CSS URL pattern: ${fontData.cssUrlPattern}
+
+${fontList}
+
+### Suggested pairings
+
+${pairingList}
+</fonts_to_consider>` : "";
+  const imageList = images.map((img) => `- ${img.analysis}`).join("\n\n");
+  const inspirationSection = images.length ? `<inspiration_images>
+## Design inspiration
+
+A random sample of pre-analyzed design references. Use these observations to inform your recommendations.
+
+${imageList}
+</inspiration_images>` : "";
+  return PROMPT_TEMPLATE.replace("{{fonts_to_consider}}", fontsSection).replace(
+    "{{inspiration_images}}",
+    inspirationSection
+  );
+}
+
+// src/subagents/designExpert/index.ts
+var DESCRIPTION = `
+A dedicated visual design expert. You have a lot on your plate as a coding agent, and design is a specialized skill \u2014 delegate visual design questions here rather than making those decisions yourself. This agent has curated font catalogs, color theory knowledge, access to design inspiration galleries, and strong opinions about what looks good. It can answer from expertise alone or research the web when needed.
+
+The visual design expert can be used for all things visual design, from quick questions to comprehensive plans:
+- Font selection and pairings ("suggest fonts for a <x> app")
+- Color palettes from a mood, domain, or seed color ("earthy tones for a <x> brand")
+- Gradient, animation, and visual effect recommendations
+- Layout and composition ideas that go beyond generic AI defaults
+- Analyzing a reference site or screenshot for design insights (it can take screenshots and do research on its own)
+- Sourcing imagery: stock photos, AI-generated images, or product screenshots for reference
+- Icon recommendations
+- Proposing full visual directions during intake
+
+**How to write the task:**
+Include context about the app \u2014 what it does, who uses it, what mood or feeling the interface should convey. More context produces better results. For quick questions ("three font pairings for a <x> app"), brief is fine. You can ask for multiple topics, multiple options, etc.
+
+**What it returns:**
+Concrete resources: hex values, font names with CSS URLs, image URLs, layout descriptions. Use the results directly in brand spec files or as guidance when building the interface.
+`.trim();
+var designExpertTool = {
+  definition: {
+    name: "visualDesignExpert",
+    description: DESCRIPTION,
+    inputSchema: {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "What you need, in natural language. Include context about the app when relevant."
+        }
+      },
+      required: ["task"]
+    }
+  },
+  async execute(input, context) {
+    if (!context) {
+      return "Error: design research requires execution context";
+    }
+    return runSubAgent({
+      system: getDesignResearchPrompt(),
+      task: input.task,
+      tools: DESIGN_RESEARCH_TOOLS,
+      externalTools: /* @__PURE__ */ new Set(),
+      executeTool: executeDesignTool,
+      apiConfig: context.apiConfig,
+      model: context.model,
+      signal: context.signal,
+      parentToolId: context.toolCallId,
+      onEvent: context.onEvent,
+      resolveExternalTool: context.resolveExternalTool
+    });
+  }
+};
+
 // src/tools/index.ts
 function getSpecTools() {
   return [readSpecTool, writeSpecTool, editSpecTool, listSpecFilesTool];
@@ -2135,7 +2724,6 @@ function getCodeTools() {
     globTool,
     listDirTool,
     editsFinishedTool,
-    askMindStudioSdkTool,
     runScenarioTool,
     runMethodTool,
     screenshotTool,
@@ -2150,7 +2738,12 @@ function getCommonTools() {
   return [
     setProjectOnboardingStateTool,
     promptUserTool,
-    confirmDestructiveActionTool
+    confirmDestructiveActionTool,
+    askMindStudioSdkTool,
+    fetchUrlTool,
+    searchGoogleTool,
+    setProjectNameTool,
+    designExpertTool
   ];
 }
 function getPostOnboardingTools() {
@@ -2197,11 +2790,11 @@ function executeTool(name, input, context) {
 }
 
 // src/session.ts
-import fs14 from "fs";
+import fs15 from "fs";
 var SESSION_FILE = ".remy-session.json";
 function loadSession(state) {
   try {
-    const raw = fs14.readFileSync(SESSION_FILE, "utf-8");
+    const raw = fs15.readFileSync(SESSION_FILE, "utf-8");
     const data = JSON.parse(raw);
     if (Array.isArray(data.messages) && data.messages.length > 0) {
       state.messages = sanitizeMessages(data.messages);
@@ -2243,7 +2836,7 @@ function sanitizeMessages(messages) {
 }
 function saveSession(state) {
   try {
-    fs14.writeFileSync(
+    fs15.writeFileSync(
       SESSION_FILE,
       JSON.stringify({ messages: state.messages }, null, 2),
       "utf-8"
@@ -2254,7 +2847,7 @@ function saveSession(state) {
 function clearSession(state) {
   state.messages = [];
   try {
-    fs14.unlinkSync(SESSION_FILE);
+    fs15.unlinkSync(SESSION_FILE);
   } catch {
   }
 }
@@ -2422,6 +3015,104 @@ function parsePartialJson(jsonString) {
   return parseAny();
 }
 
+// src/statusWatcher.ts
+function startStatusWatcher(config) {
+  const { apiConfig, getContext, onStatus, interval = 3e3, signal } = config;
+  let lastLabel = "";
+  let inflight = false;
+  const url = `${apiConfig.baseUrl}/_internal/v2/agent/remy/generate-status`;
+  async function tick() {
+    if (signal?.aborted || inflight) {
+      return;
+    }
+    inflight = true;
+    try {
+      const ctx = getContext();
+      if (!ctx.assistantText && !ctx.lastToolName) {
+        log.debug("Status watcher: no context, skipping");
+        return;
+      }
+      log.debug("Status watcher: requesting label", {
+        textLength: ctx.assistantText.length,
+        lastToolName: ctx.lastToolName
+      });
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiConfig.apiKey}`
+        },
+        body: JSON.stringify({
+          assistantText: ctx.assistantText.slice(-500),
+          lastToolName: ctx.lastToolName,
+          lastToolResult: ctx.lastToolResult?.slice(-200)
+        }),
+        signal
+      });
+      if (!res.ok) {
+        log.debug("Status watcher: endpoint returned non-ok", {
+          status: res.status
+        });
+        return;
+      }
+      const data = await res.json();
+      if (!data.label) {
+        log.debug("Status watcher: no label in response");
+        return;
+      }
+      if (data.label === lastLabel) {
+        log.debug("Status watcher: duplicate label, skipping", {
+          label: data.label
+        });
+        return;
+      }
+      lastLabel = data.label;
+      log.debug("Status watcher: emitting", { label: data.label });
+      onStatus(data.label);
+    } catch (err) {
+      log.debug("Status watcher: error", { error: err?.message ?? "unknown" });
+    } finally {
+      inflight = false;
+    }
+  }
+  const timer = setInterval(tick, interval);
+  tick().catch(() => {
+  });
+  log.debug("Status watcher started", { interval });
+  return {
+    stop() {
+      clearInterval(timer);
+      log.debug("Status watcher stopped");
+    }
+  };
+}
+
+// src/errors.ts
+var patterns = [
+  [
+    /Network error/i,
+    "Lost connection to the server. Please check your internet connection and try again."
+  ],
+  [
+    /HTTP 429|rate limit/i,
+    "Too many requests. Please wait a moment and try again."
+  ],
+  [/HTTP 40[13]/i, "Authentication failed. Please check your API key."],
+  [
+    /HTTP 5\d\d/i,
+    "The AI service is temporarily unavailable. Please try again."
+  ],
+  [/Stream stalled/i, "The connection was interrupted. Please try again."]
+];
+function friendlyError(raw) {
+  for (const [pattern, message] of patterns) {
+    if (pattern.test(raw)) {
+      return message;
+    }
+  }
+  return `Something went wrong: ${raw}`;
+}
+
 // src/agent.ts
 var EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "promptUser",
@@ -2434,7 +3125,8 @@ var EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "runScenario",
   "runMethod",
   "browserCommand",
-  "screenshot"
+  "screenshot",
+  "setProjectName"
 ]);
 function createAgentState() {
   return { messages: [] };
@@ -2464,7 +3156,8 @@ async function runTurn(params) {
     }
   });
   onEvent({ type: "turn_started" });
-  const userMsg = { role: "user", content: userMessage };
+  const cleanMessage = userMessage.replace(/^@@automated::[^@]*@@/, "");
+  const userMsg = { role: "user", content: cleanMessage };
   if (hidden) {
     userMsg.hidden = true;
   }
@@ -2558,15 +3251,34 @@ async function runTurn(params) {
         onEvent({ type: "tool_input_delta", id, name, result: content });
       }
     }
+    const statusWatcher = startStatusWatcher({
+      apiConfig,
+      getContext: () => ({
+        assistantText: assistantText.slice(-500),
+        lastToolName: toolCalls.at(-1)?.name
+      }),
+      onStatus: (label) => onEvent({ type: "status", message: label }),
+      signal
+    });
     try {
-      for await (const event of streamChat({
-        ...apiConfig,
-        model,
-        system,
-        messages: state.messages,
-        tools,
-        signal
-      })) {
+      for await (const event of streamChatWithRetry(
+        {
+          ...apiConfig,
+          model,
+          system,
+          messages: state.messages,
+          tools,
+          signal
+        },
+        {
+          onRetry: (attempt) => {
+            onEvent({
+              type: "status",
+              message: `Lost connection, retrying (attempt ${attempt + 2} of 3)...`
+            });
+          }
+        }
+      )) {
         if (signal?.aborted) {
           break;
         }
@@ -2634,7 +3346,7 @@ async function runTurn(params) {
             stopReason = event.stopReason;
             break;
           case "error":
-            onEvent({ type: "error", error: event.error });
+            onEvent({ type: "error", error: friendlyError(event.error) });
             return;
         }
       }
@@ -2643,6 +3355,8 @@ async function runTurn(params) {
       } else {
         throw err;
       }
+    } finally {
+      statusWatcher.stop();
     }
     if (signal?.aborted) {
       if (assistantText) {
@@ -2670,6 +3384,15 @@ async function runTurn(params) {
       count: toolCalls.length,
       tools: toolCalls.map((tc) => tc.name)
     });
+    const toolStatusWatcher = startStatusWatcher({
+      apiConfig,
+      getContext: () => ({
+        assistantText: assistantText.slice(-500),
+        lastToolName: toolCalls.map((tc) => tc.name).join(", ")
+      }),
+      onStatus: (label) => onEvent({ type: "status", message: label }),
+      signal
+    });
     const results = await Promise.all(
       toolCalls.map(async (tc) => {
         if (signal?.aborted) {
@@ -2727,6 +3450,7 @@ async function runTurn(params) {
         }
       })
     );
+    toolStatusWatcher.stop();
     for (const r of results) {
       state.messages.push({
         role: "user",
@@ -2744,10 +3468,10 @@ async function runTurn(params) {
 }
 
 // src/headless.ts
-var BASE_DIR = import.meta.dirname ?? path8.dirname(new URL(import.meta.url).pathname);
-var ACTIONS_DIR = path8.join(BASE_DIR, "actions");
+var BASE_DIR = import.meta.dirname ?? path9.dirname(new URL(import.meta.url).pathname);
+var ACTIONS_DIR = path9.join(BASE_DIR, "actions");
 function loadActionPrompt(name) {
-  return fs15.readFileSync(path8.join(ACTIONS_DIR, `${name}.md`), "utf-8").trim();
+  return fs16.readFileSync(path9.join(ACTIONS_DIR, `${name}.md`), "utf-8").trim();
 }
 function emit(event, data) {
   process.stdout.write(JSON.stringify({ event, ...data }) + "\n");
@@ -2775,6 +3499,7 @@ async function startHeadless(opts = {}) {
   }
   let running = false;
   let currentAbort = null;
+  const EXTERNAL_TOOL_TIMEOUT_MS = 3e5;
   const pendingTools = /* @__PURE__ */ new Map();
   const earlyResults = /* @__PURE__ */ new Map();
   function onEvent(e) {
@@ -2829,6 +3554,9 @@ async function startHeadless(opts = {}) {
       case "error":
         emit("error", { error: e.error });
         break;
+      case "status":
+        emit("status", { message: e.message });
+        break;
     }
   }
   function resolveExternalTool(id, _name, _input) {
@@ -2838,7 +3566,19 @@ async function startHeadless(opts = {}) {
       return Promise.resolve(early);
     }
     return new Promise((resolve) => {
-      pendingTools.set(id, { resolve });
+      const timeout = setTimeout(() => {
+        pendingTools.delete(id);
+        resolve(
+          "Error: Tool timed out \u2014 no response from the app environment after 5 minutes."
+        );
+      }, EXTERNAL_TOOL_TIMEOUT_MS);
+      pendingTools.set(id, {
+        resolve: (result) => {
+          clearTimeout(timeout);
+          resolve(result);
+        },
+        timeout
+      });
     });
   }
   const rl = createInterface({ input: process.stdin });
@@ -2876,6 +3616,7 @@ async function startHeadless(opts = {}) {
         currentAbort.abort();
       }
       for (const [id, pending] of pendingTools) {
+        clearTimeout(pending.timeout);
         pending.resolve("Error: cancelled");
         pendingTools.delete(id);
       }