@mindstudio-ai/remy 0.1.8 → 0.1.10

package/dist/index.js

@@ -146,11 +146,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;
     }
@@ -184,10 +208,55 @@ async function* streamChat(params) {
     }
   }
 }
+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;
+  }
+}
+var MAX_RETRIES, INITIAL_BACKOFF_MS;
 var init_api = __esm({
   "src/api.ts"() {
     "use strict";
     init_logger();
+    MAX_RETRIES = 3;
+    INITIAL_BACKOFF_MS = 1e3;
   }
 });
 
@@ -634,10 +703,115 @@ var init_listSpecFiles = __esm({
   }
 });
 
-// src/tools/spec/setProjectOnboardingState.ts
+// src/tools/spec/clearSyncStatus.ts
+var clearSyncStatusTool;
+var init_clearSyncStatus = __esm({
+  "src/tools/spec/clearSyncStatus.ts"() {
+    "use strict";
+    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;
+var init_presentSyncPlan = __esm({
+  "src/tools/spec/presentSyncPlan.ts"() {
+    "use strict";
+    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;
+var init_presentPublishPlan = __esm({
+  "src/tools/spec/presentPublishPlan.ts"() {
+    "use strict";
+    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;
+var init_presentPlan = __esm({
+  "src/tools/spec/presentPlan.ts"() {
+    "use strict";
+    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;
 var init_setProjectOnboardingState = __esm({
-  "src/tools/spec/setProjectOnboardingState.ts"() {
+  "src/tools/common/setProjectOnboardingState.ts"() {
     "use strict";
     setProjectOnboardingStateTool = {
       definition: {
@@ -666,10 +840,10 @@ var init_setProjectOnboardingState = __esm({
   }
 });
 
-// src/tools/spec/promptUser.ts
+// src/tools/common/promptUser.ts
 var promptUserTool;
 var init_promptUser = __esm({
-  "src/tools/spec/promptUser.ts"() {
+  "src/tools/common/promptUser.ts"() {
     "use strict";
     promptUserTool = {
       definition: {
@@ -698,8 +872,8 @@ var init_promptUser = __esm({
                   },
                   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",
@@ -736,10 +910,6 @@ var init_promptUser = __esm({
                     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"],
@@ -797,8 +967,6 @@ var init_promptUser = __esm({
             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;
         });
@@ -809,141 +977,209 @@ ${lines.join("\n")}`;
   }
 });
 
-// src/tools/spec/clearSyncStatus.ts
-var clearSyncStatusTool;
-var init_clearSyncStatus = __esm({
-  "src/tools/spec/clearSyncStatus.ts"() {
+// src/tools/common/confirmDestructiveAction.ts
+var confirmDestructiveActionTool;
+var init_confirmDestructiveAction = __esm({
+  "src/tools/common/confirmDestructiveAction.ts"() {
     "use strict";
-    clearSyncStatusTool = {
+    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;
-var init_presentSyncPlan = __esm({
-  "src/tools/spec/presentSyncPlan.ts"() {
+// src/tools/common/askMindStudioSdk.ts
+import { exec } from "child_process";
+var askMindStudioSdkTool;
+var init_askMindStudioSdk = __esm({
+  "src/tools/common/askMindStudioSdk.ts"() {
     "use strict";
-    presentSyncPlanTool = {
+    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;
-var init_presentPublishPlan = __esm({
-  "src/tools/spec/presentPublishPlan.ts"() {
+// src/tools/common/fetchUrl.ts
+import { exec as exec2 } from "child_process";
+var fetchUrlTool;
+var init_fetchUrl = __esm({
+  "src/tools/common/fetchUrl.ts"() {
     "use strict";
-    presentPublishPlanTool = {
+    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;
-var init_presentPlan = __esm({
-  "src/tools/spec/presentPlan.ts"() {
+// src/tools/common/searchGoogle.ts
+import { exec as exec3 } from "child_process";
+var searchGoogleTool;
+var init_searchGoogle = __esm({
+  "src/tools/common/searchGoogle.ts"() {
     "use strict";
-    presentPlanTool = {
+    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";
-      }
-    };
-  }
-});
-
-// src/tools/spec/confirmDestructiveAction.ts
-var confirmDestructiveActionTool;
-var init_confirmDestructiveAction = __esm({
-  "src/tools/spec/confirmDestructiveAction.ts"() {
+      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/common/setProjectName.ts
+var setProjectNameTool;
+var init_setProjectName = __esm({
+  "src/tools/common/setProjectName.ts"() {
     "use strict";
-    confirmDestructiveActionTool = {
+    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";
       }
     };
   }
@@ -952,9 +1188,9 @@ var init_confirmDestructiveAction = __esm({
 // src/tools/code/readFile.ts
 import fs6 from "fs/promises";
 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;
     }
   }
@@ -1273,7 +1509,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, DEFAULT_MAX_LINES3, bashTool;
 var init_bash = __esm({
   "src/tools/code/bash.ts"() {
@@ -1311,7 +1547,7 @@ var init_bash = __esm({
         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,
@@ -1353,7 +1589,7 @@ var init_bash = __esm({
 });
 
 // src/tools/code/grep.ts
-import { exec as exec2 } from "child_process";
+import { exec as exec5 } from "child_process";
 function formatResults(stdout, max) {
   const lines = stdout.trim().split("\n");
   let result = lines.join("\n");
@@ -1404,12 +1640,12 @@ var init_grep = __esm({
         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 {
@@ -1669,51 +1905,6 @@ var init_restartProcess = __esm({
   }
 });
 
-// src/tools/code/askMindStudioSdk.ts
-import { exec as exec3 } from "child_process";
-var askMindStudioSdkTool;
-var init_askMindStudioSdk = __esm({
-  "src/tools/code/askMindStudioSdk.ts"() {
-    "use strict";
-    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;
 var init_runScenario = __esm({
@@ -1820,7 +2011,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,
@@ -1912,133 +2103,567 @@ async function runSubAgent(config) {
           });
           return { id: tc.id, result: errorMsg, isError: true };
         }
-      })
-    );
-    for (const r of results) {
-      messages.push({
-        role: "user",
-        content: r.result,
-        toolCallId: r.id,
-        isToolError: r.isError
-      });
-    }
-  }
-}
-var init_runner = __esm({
-  "src/subagents/runner.ts"() {
-    "use strict";
-    init_api();
-    init_logger();
-  }
-});
-
-// src/subagents/browserAutomation/tools.ts
-var BROWSER_TOOLS, BROWSER_EXTERNAL_TOOLS;
-var init_tools = __esm({
-  "src/subagents/browserAutomation/tools.ts"() {
-    "use strict";
-    BROWSER_TOOLS = [
+      })
+    );
+    for (const r of results) {
+      messages.push({
+        role: "user",
+        content: r.result,
+        toolCallId: r.id,
+        isToolError: r.isError
+      });
+    }
+  }
+}
+var init_runner = __esm({
+  "src/subagents/runner.ts"() {
+    "use strict";
+    init_api();
+    init_logger();
+  }
+});
+
+// src/subagents/browserAutomation/tools.ts
+var BROWSER_TOOLS, BROWSER_EXTERNAL_TOOLS;
+var init_tools = __esm({
+  "src/subagents/browserAutomation/tools.ts"() {
+    "use strict";
+    BROWSER_TOOLS = [
+      {
+        name: "browserCommand",
+        description: "Interact with the app's live preview by sending browser commands. Commands execute sequentially with an animated cursor. Always start with a snapshot to see the current state and get ref identifiers. The result includes a snapshot field with the final page state after all steps complete. On error, the failing step has an error field and execution stops. Timeout: 120s.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            steps: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  command: {
+                    type: "string",
+                    enum: ["snapshot", "click", "type", "wait", "evaluate"],
+                    description: "snapshot: accessibility tree of the page (waits for network to settle). click: click an element (animated cursor, full event sequence). type: type text into input (one char at a time, works with React/Vue/Svelte). wait: wait for an element to appear (polls 100ms, waits for network). evaluate: run JS in the page."
+                  },
+                  ref: {
+                    type: "string",
+                    description: "Element ref from the last snapshot (most reliable targeting)."
+                  },
+                  text: {
+                    type: "string",
+                    description: "For click/wait: match by accessible name or visible text. For type: the text to type."
+                  },
+                  role: {
+                    type: "string",
+                    description: "ARIA role to match (used with text for role+text targeting)."
+                  },
+                  label: {
+                    type: "string",
+                    description: "Find an input by its associated label text."
+                  },
+                  selector: {
+                    type: "string",
+                    description: "CSS selector fallback (last resort)."
+                  },
+                  clear: {
+                    type: "boolean",
+                    description: "For type: clear the field before typing."
+                  },
+                  timeout: {
+                    type: "number",
+                    description: "For wait: timeout in ms (default 5000)."
+                  },
+                  script: {
+                    type: "string",
+                    description: "For evaluate: JavaScript to run in the page."
+                  }
+                },
+                required: ["command"]
+              }
+            }
+          },
+          required: ["steps"]
+        }
+      },
+      {
+        name: "screenshot",
+        description: "Capture a screenshot of the current page. Returns a CDN URL with dimensions.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      }
+    ];
+    BROWSER_EXTERNAL_TOOLS = /* @__PURE__ */ new Set(["browserCommand", "screenshot"]);
+  }
+});
+
+// src/subagents/browserAutomation/prompt.ts
+import fs10 from "fs";
+import path4 from "path";
+var base, local, PROMPT_PATH, BROWSER_AUTOMATION_PROMPT;
+var init_prompt = __esm({
+  "src/subagents/browserAutomation/prompt.ts"() {
+    "use strict";
+    base = import.meta.dirname ?? path4.dirname(new URL(import.meta.url).pathname);
+    local = path4.join(base, "prompt.md");
+    PROMPT_PATH = fs10.existsSync(local) ? local : path4.join(base, "subagents", "browserAutomation", "prompt.md");
+    BROWSER_AUTOMATION_PROMPT = fs10.readFileSync(PROMPT_PATH, "utf-8").trim();
+  }
+});
+
+// src/subagents/browserAutomation/index.ts
+var browserAutomationTool;
+var init_browserAutomation = __esm({
+  "src/subagents/browserAutomation/index.ts"() {
+    "use strict";
+    init_runner();
+    init_tools();
+    init_prompt();
+    browserAutomationTool = {
+      definition: {
+        name: "runAutomatedBrowserTest",
+        description: "Run an automated browser test against the live preview. The test agent always starts on the main page, so include navigation instructions if the test involves a sub-page. The browser uses the current user roles and dev database state, so run a scenario first if you need specific data or roles. Use after writing or modifying frontend code, to reproduce user-reported issues, or to test end-to-end flows.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            task: {
+              type: "string",
+              description: "What to test, in natural language. Include how to navigate to the relevant page and what data/roles to expect."
+            }
+          },
+          required: ["task"]
+        }
+      },
+      async execute(input, context) {
+        if (!context) {
+          return "Error: browser automation requires execution context (only available in headless mode)";
+        }
+        return runSubAgent({
+          system: BROWSER_AUTOMATION_PROMPT,
+          task: input.task,
+          tools: BROWSER_TOOLS,
+          externalTools: BROWSER_EXTERNAL_TOOLS,
+          executeTool: async () => "Error: no local tools in browser automation",
+          apiConfig: context.apiConfig,
+          model: context.model,
+          signal: context.signal,
+          parentToolId: context.toolCallId,
+          onEvent: context.onEvent,
+          resolveExternalTool: context.resolveExternalTool
+        });
+      }
+    };
+  }
+});
+
+// src/subagents/designExpert/tools.ts
+import { exec as exec6 } from "child_process";
+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}"`;
+  }
+}
+var DESIGN_REFERENCE_PROMPT, DESIGN_RESEARCH_TOOLS;
+var init_tools2 = __esm({
+  "src/subagents/designExpert/tools.ts"() {
+    "use strict";
+    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.`;
+    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: "browserCommand",
-        description: "Interact with the app's live preview by sending browser commands. Commands execute sequentially with an animated cursor. Always start with a snapshot to see the current state and get ref identifiers. The result includes a snapshot field with the final page state after all steps complete. On error, the failing step has an error field and execution stops. Timeout: 120s.",
+        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: {
-            steps: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  command: {
-                    type: "string",
-                    enum: ["snapshot", "click", "type", "wait", "evaluate"],
-                    description: "snapshot: accessibility tree of the page (waits for network to settle). click: click an element (animated cursor, full event sequence). type: type text into input (one char at a time, works with React/Vue/Svelte). wait: wait for an element to appear (polls 100ms, waits for network). evaluate: run JS in the page."
-                  },
-                  ref: {
-                    type: "string",
-                    description: "Element ref from the last snapshot (most reliable targeting)."
-                  },
-                  text: {
-                    type: "string",
-                    description: "For click/wait: match by accessible name or visible text. For type: the text to type."
-                  },
-                  role: {
-                    type: "string",
-                    description: "ARIA role to match (used with text for role+text targeting)."
-                  },
-                  label: {
-                    type: "string",
-                    description: "Find an input by its associated label text."
-                  },
-                  selector: {
-                    type: "string",
-                    description: "CSS selector fallback (last resort)."
-                  },
-                  clear: {
-                    type: "boolean",
-                    description: "For type: clear the field before typing."
-                  },
-                  timeout: {
-                    type: "number",
-                    description: "For wait: timeout in ms (default 5000)."
-                  },
-                  script: {
-                    type: "string",
-                    description: "For evaluate: JavaScript to run in the page."
-                  }
-                },
-                required: ["command"]
-              }
+            query: {
+              type: "string",
+              description: "What kind of photo to search for."
             }
           },
-          required: ["steps"]
+          required: ["query"]
         }
       },
       {
-        name: "screenshot",
-        description: "Capture a screenshot of the current page. Returns a CDN URL with dimensions.",
+        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: {}
+          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"]
         }
       }
     ];
-    BROWSER_EXTERNAL_TOOLS = /* @__PURE__ */ new Set(["browserCommand", "screenshot"]);
   }
 });
 
-// src/subagents/browserAutomation/prompt.ts
-import fs10 from "fs";
-import path4 from "path";
-var base, local, PROMPT_PATH, BROWSER_AUTOMATION_PROMPT;
-var init_prompt = __esm({
-  "src/subagents/browserAutomation/prompt.ts"() {
+// src/subagents/designExpert/prompt.ts
+import fs11 from "fs";
+import path5 from "path";
+function resolvePath(filename) {
+  const local2 = path5.join(base2, filename);
+  return fs11.existsSync(local2) ? local2 : path5.join(base2, "subagents", "designExpert", filename);
+}
+function readFile(filename) {
+  return fs11.readFileSync(resolvePath(filename), "utf-8").trim();
+}
+function readJson(filename, fallback) {
+  try {
+    return JSON.parse(fs11.readFileSync(resolvePath(filename), "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+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
+  );
+}
+var base2, RUNTIME_PLACEHOLDERS, PROMPT_TEMPLATE, fontData, inspirationImages;
+var init_prompt2 = __esm({
+  "src/subagents/designExpert/prompt.ts"() {
     "use strict";
-    base = import.meta.dirname ?? path4.dirname(new URL(import.meta.url).pathname);
-    local = path4.join(base, "prompt.md");
-    PROMPT_PATH = fs10.existsSync(local) ? local : path4.join(base, "subagents", "browserAutomation", "prompt.md");
-    BROWSER_AUTOMATION_PROMPT = fs10.readFileSync(PROMPT_PATH, "utf-8").trim();
+    base2 = import.meta.dirname ?? path5.dirname(new URL(import.meta.url).pathname);
+    RUNTIME_PLACEHOLDERS = /* @__PURE__ */ new Set([
+      "fonts_to_consider",
+      "inspiration_images"
+    ]);
+    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");
+    fontData = readJson("data/fonts.json", {
+      cssUrlPattern: "",
+      fonts: [],
+      pairings: []
+    });
+    inspirationImages = readJson("data/inspiration.json", {
+      images: []
+    }).images;
   }
 });
 
-// src/subagents/browserAutomation/index.ts
-var browserAutomationTool;
-var init_browserAutomation = __esm({
-  "src/subagents/browserAutomation/index.ts"() {
+// src/subagents/designExpert/index.ts
+var DESCRIPTION, designExpertTool;
+var init_designExpert = __esm({
+  "src/subagents/designExpert/index.ts"() {
     "use strict";
     init_runner();
-    init_tools();
-    init_prompt();
-    browserAutomationTool = {
+    init_tools2();
+    init_prompt2();
+    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();
+    designExpertTool = {
       definition: {
-        name: "runAutomatedBrowserTest",
-        description: "Run an automated browser test against the live preview. The test agent always starts on the main page, so include navigation instructions if the test involves a sub-page. The browser uses the current user roles and dev database state, so run a scenario first if you need specific data or roles. Use after writing or modifying frontend code, to reproduce user-reported issues, or to test end-to-end flows.",
+        name: "visualDesignExpert",
+        description: DESCRIPTION,
         inputSchema: {
           type: "object",
           properties: {
             task: {
               type: "string",
-              description: "What to test, in natural language. Include how to navigate to the relevant page and what data/roles to expect."
+              description: "What you need, in natural language. Include context about the app when relevant."
             }
           },
           required: ["task"]
@@ -2046,14 +2671,14 @@ var init_browserAutomation = __esm({
       },
       async execute(input, context) {
         if (!context) {
-          return "Error: browser automation requires execution context (only available in headless mode)";
+          return "Error: design research requires execution context";
         }
         return runSubAgent({
-          system: BROWSER_AUTOMATION_PROMPT,
+          system: getDesignResearchPrompt(),
           task: input.task,
-          tools: BROWSER_TOOLS,
-          externalTools: BROWSER_EXTERNAL_TOOLS,
-          executeTool: async () => "Error: no local tools in browser automation",
+          tools: DESIGN_RESEARCH_TOOLS,
+          externalTools: /* @__PURE__ */ new Set(),
+          executeTool: executeDesignTool,
           apiConfig: context.apiConfig,
           model: context.model,
           signal: context.signal,
@@ -2080,7 +2705,6 @@ function getCodeTools() {
     globTool,
     listDirTool,
     editsFinishedTool,
-    askMindStudioSdkTool,
     runScenarioTool,
     runMethodTool,
     screenshotTool,
@@ -2095,7 +2719,12 @@ function getCommonTools() {
   return [
     setProjectOnboardingStateTool,
     promptUserTool,
-    confirmDestructiveActionTool
+    confirmDestructiveActionTool,
+    askMindStudioSdkTool,
+    fetchUrlTool,
+    searchGoogleTool,
+    setProjectNameTool,
+    designExpertTool
   ];
 }
 function getPostOnboardingTools() {
@@ -2140,20 +2769,24 @@ function executeTool(name, input, context) {
   }
   return tool.execute(input, context);
 }
-var init_tools2 = __esm({
+var init_tools3 = __esm({
   "src/tools/index.ts"() {
     "use strict";
     init_readSpec();
     init_writeSpec();
     init_editSpec();
     init_listSpecFiles();
-    init_setProjectOnboardingState();
-    init_promptUser();
     init_clearSyncStatus();
     init_presentSyncPlan();
     init_presentPublishPlan();
     init_presentPlan();
+    init_setProjectOnboardingState();
+    init_promptUser();
     init_confirmDestructiveAction();
+    init_askMindStudioSdk();
+    init_fetchUrl();
+    init_searchGoogle();
+    init_setProjectName();
     init_readFile();
     init_writeFile();
     init_editFile();
@@ -2165,19 +2798,19 @@ var init_tools2 = __esm({
     init_lsp();
     init_lspDiagnostics();
     init_restartProcess();
-    init_askMindStudioSdk();
     init_runScenario();
     init_runMethod();
     init_screenshot();
     init_browserAutomation();
+    init_designExpert();
   }
 });
 
 // src/session.ts
-import fs11 from "fs";
+import fs12 from "fs";
 function loadSession(state) {
   try {
-    const raw = fs11.readFileSync(SESSION_FILE, "utf-8");
+    const raw = fs12.readFileSync(SESSION_FILE, "utf-8");
     const data = JSON.parse(raw);
     if (Array.isArray(data.messages) && data.messages.length > 0) {
       state.messages = sanitizeMessages(data.messages);
@@ -2219,7 +2852,7 @@ function sanitizeMessages(messages) {
 }
 function saveSession(state) {
   try {
-    fs11.writeFileSync(
+    fs12.writeFileSync(
       SESSION_FILE,
       JSON.stringify({ messages: state.messages }, null, 2),
       "utf-8"
@@ -2230,7 +2863,7 @@ function saveSession(state) {
 function clearSession(state) {
   state.messages = [];
   try {
-    fs11.unlinkSync(SESSION_FILE);
+    fs12.unlinkSync(SESSION_FILE);
   } catch {
   }
 }
@@ -2411,6 +3044,116 @@ var init_parsePartialJson = __esm({
   }
 });
 
+// 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");
+    }
+  };
+}
+var init_statusWatcher = __esm({
+  "src/statusWatcher.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/errors.ts
+function friendlyError(raw) {
+  for (const [pattern, message] of patterns) {
+    if (pattern.test(raw)) {
+      return message;
+    }
+  }
+  return `Something went wrong: ${raw}`;
+}
+var patterns;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    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."]
+    ];
+  }
+});
+
 // src/agent.ts
 function createAgentState() {
   return { messages: [] };
@@ -2440,7 +3183,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;
   }
@@ -2534,15 +3278,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;
         }
@@ -2610,7 +3373,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;
         }
       }
@@ -2619,6 +3382,8 @@ async function runTurn(params) {
       } else {
         throw err;
       }
+    } finally {
+      statusWatcher.stop();
     }
     if (signal?.aborted) {
       if (assistantText) {
@@ -2646,6 +3411,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) {
@@ -2703,6 +3477,7 @@ async function runTurn(params) {
         }
       })
     );
+    toolStatusWatcher.stop();
     for (const r of results) {
       state.messages.push({
         role: "user",
@@ -2723,10 +3498,12 @@ var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
     init_api();
-    init_tools2();
+    init_tools3();
     init_session();
     init_logger();
     init_parsePartialJson();
+    init_statusWatcher();
+    init_errors();
     EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
       "promptUser",
       "setProjectOnboardingState",
@@ -2738,18 +3515,19 @@ var init_agent = __esm({
       "runScenario",
       "runMethod",
       "browserCommand",
-      "screenshot"
+      "screenshot",
+      "setProjectName"
     ]);
   }
 });
 
 // src/prompt/static/projectContext.ts
-import fs12 from "fs";
-import path5 from "path";
+import fs13 from "fs";
+import path6 from "path";
 function loadProjectInstructions() {
   for (const file of AGENT_INSTRUCTION_FILES) {
     try {
-      const content = fs12.readFileSync(file, "utf-8").trim();
+      const content = fs13.readFileSync(file, "utf-8").trim();
       if (content) {
         return `
 ## Project Instructions (${file})
@@ -2762,7 +3540,7 @@ ${content}`;
 }
 function loadProjectManifest() {
   try {
-    const manifest = fs12.readFileSync("mindstudio.json", "utf-8");
+    const manifest = fs13.readFileSync("mindstudio.json", "utf-8");
     return `
 ## Project Manifest (mindstudio.json)
 \`\`\`json
@@ -2780,11 +3558,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}`;
       }
@@ -2800,9 +3581,9 @@ ${entries.join("\n")}`;
 function walkMdFiles(dir) {
   const results = [];
   try {
-    const entries = fs12.readdirSync(dir, { withFileTypes: true });
+    const entries = fs13.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path5.join(dir, entry.name);
+      const full = path6.join(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...walkMdFiles(full));
       } else if (entry.name.endsWith(".md")) {
@@ -2815,22 +3596,23 @@ function walkMdFiles(dir) {
 }
 function parseFrontmatter(filePath) {
   try {
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const content = fs13.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() {
   try {
-    const entries = fs12.readdirSync(".", { withFileTypes: true });
+    const entries = fs13.readdirSync(".", { withFileTypes: true });
     const listing = entries.filter((e) => e.name !== ".git" && e.name !== "node_modules").sort((a, b) => {
       if (a.isDirectory() && !b.isDirectory()) {
         return -1;
@@ -2873,12 +3655,12 @@ var init_projectContext = __esm({
 });
 
 // src/prompt/index.ts
-import fs13 from "fs";
-import path6 from "path";
+import fs14 from "fs";
+import path7 from "path";
 function requireFile(filePath) {
-  const full = path6.join(PROMPT_DIR, filePath);
+  const full = path7.join(PROMPT_DIR, filePath);
   try {
-    return fs13.readFileSync(full, "utf-8").trim();
+    return fs14.readFileSync(full, "utf-8").trim();
   } catch {
     throw new Error(`Required prompt file missing: ${full}`);
   }
@@ -2998,22 +3780,22 @@ ${viewContext?.activeFile ? `Active file: ${viewContext.activeFile}` : ""}
   return resolveIncludes(template);
 }
 var PROMPT_DIR;
-var init_prompt2 = __esm({
+var init_prompt3 = __esm({
   "src/prompt/index.ts"() {
     "use strict";
     init_lsp();
     init_projectContext();
-    PROMPT_DIR = import.meta.dirname ?? path6.dirname(new URL(import.meta.url).pathname);
+    PROMPT_DIR = import.meta.dirname ?? path7.dirname(new URL(import.meta.url).pathname);
   }
 });
 
 // src/config.ts
-import fs14 from "fs";
-import path7 from "path";
+import fs15 from "fs";
+import path8 from "path";
 import os from "os";
 function loadConfigFile() {
   try {
-    const raw = fs14.readFileSync(CONFIG_PATH, "utf-8");
+    const raw = fs15.readFileSync(CONFIG_PATH, "utf-8");
     log.debug("Loaded config file", { path: CONFIG_PATH });
     return JSON.parse(raw);
   } catch (err) {
@@ -3049,7 +3831,7 @@ var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_logger();
-    CONFIG_PATH = path7.join(
+    CONFIG_PATH = path8.join(
       os.homedir(),
       ".mindstudio-local-tunnel",
       "config.json"
@@ -3064,10 +3846,10 @@ __export(headless_exports, {
   startHeadless: () => startHeadless
 });
 import { createInterface } from "readline";
-import fs15 from "fs";
-import path8 from "path";
+import fs16 from "fs";
+import path9 from "path";
 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");
@@ -3095,6 +3877,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) {
@@ -3149,6 +3932,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) {
@@ -3158,7 +3944,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 });
@@ -3196,6 +3994,7 @@ async function startHeadless(opts = {}) {
         currentAbort.abort();
       }
       for (const [id, pending] of pendingTools) {
+        clearTimeout(pending.timeout);
         pending.resolve("Error: cancelled");
         pendingTools.delete(id);
       }
@@ -3265,20 +4064,20 @@ var init_headless = __esm({
   "src/headless.ts"() {
     "use strict";
     init_config();
-    init_prompt2();
+    init_prompt3();
     init_lsp();
     init_agent();
     init_session();
-    BASE_DIR = import.meta.dirname ?? path8.dirname(new URL(import.meta.url).pathname);
-    ACTIONS_DIR = path8.join(BASE_DIR, "actions");
+    BASE_DIR = import.meta.dirname ?? path9.dirname(new URL(import.meta.url).pathname);
+    ACTIONS_DIR = path9.join(BASE_DIR, "actions");
   }
 });
 
 // src/index.tsx
 import { render } from "ink";
 import os2 from "os";
-import fs16 from "fs";
-import path9 from "path";
+import fs17 from "fs";
+import path10 from "path";
 
 // src/tui/App.tsx
 import { useState as useState2, useCallback, useRef } from "react";
@@ -3413,7 +4212,7 @@ function MessageList({ turns }) {
 
 // src/tui/App.tsx
 init_agent();
-init_prompt2();
+init_prompt3();
 init_session();
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 function App({ apiConfig, model }) {
@@ -3595,8 +4394,8 @@ for (let i = 0; i < args.length; i++) {
 }
 function printDebugInfo(config) {
   const pkg = JSON.parse(
-    fs16.readFileSync(
-      path9.join(import.meta.dirname, "..", "package.json"),
+    fs17.readFileSync(
+      path10.join(import.meta.dirname, "..", "package.json"),
       "utf-8"
     )
   );