@mindstudio-ai/remy 0.1.19 → 0.1.21

package/dist/index.js

@@ -1012,23 +1012,46 @@ var init_confirmDestructiveAction = __esm({
   }
 });
 
-// src/tools/common/askMindStudioSdk.ts
+// src/subagents/common/runCli.ts
 import { exec } from "child_process";
+function runCli(cmd, options) {
+  return new Promise((resolve) => {
+    exec(
+      cmd,
+      {
+        timeout: options?.timeout ?? 6e4,
+        maxBuffer: options?.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)");
+      }
+    );
+  });
+}
+var init_runCli = __esm({
+  "src/subagents/common/runCli.ts"() {
+    "use strict";
+  }
+});
+
+// src/subagents/sdkConsultant/index.ts
 var askMindStudioSdkTool;
-var init_askMindStudioSdk = __esm({
-  "src/tools/common/askMindStudioSdk.ts"() {
+var init_sdkConsultant = __esm({
+  "src/subagents/sdkConsultant/index.ts"() {
     "use strict";
+    init_runCli();
     askMindStudioSdkTool = {
       definition: {
         name: "askMindStudioSdk",
-        description: `An expert consultant on building with the MindStudio SDK. Knows every action, model, connector, and configuration option. Use this as an architect, not just a docs lookup:
-
-- Describe what you're trying to build at the method level ("I need a method that takes user text, generates a summary with GPT, extracts entities, and returns structured JSON") and get back architectural guidance + working code.
-- Ask about AI orchestration patterns: structured output, chaining model calls, batch processing, streaming, error handling.
-- Ask about connectors and integrations: what's available, whether the user has configured it, how to use it.
-- Always use this before writing SDK code. Model IDs, config options, and action signatures change frequently. Don't guess.
-
-Batch related questions into a single query. This runs its own LLM call so it has a few seconds of latency.`,
+        description: "MindStudio SDK expert. Knows every action, model, connector, and configuration option. Returns architectural guidance and working code. Describe what you want to build, not just what API method you need. Batch related questions into a single query.",
         inputSchema: {
           type: "object",
           properties: {
@@ -1042,22 +1065,8 @@ Batch related questions into a single query. This runs its own LLM call so it ha
       },
       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)");
-            }
-          );
+        return runCli(`mindstudio ask ${JSON.stringify(query)}`, {
+          maxBuffer: 512 * 1024
         });
       }
     };
@@ -1065,11 +1074,11 @@ Batch related questions into a single query. This runs its own LLM call so it ha
 });
 
 // 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";
+    init_runCli();
     fetchUrlTool = {
       definition: {
         name: "scapeWebUrl",
@@ -1096,35 +1105,20 @@ var init_fetchUrl = __esm({
         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)");
-            }
-          );
-        });
+        return runCli(
+          `mindstudio scrape-url --url ${JSON.stringify(url)} --page-options ${JSON.stringify(JSON.stringify(pageOptions))} --no-meta`
+        );
       }
     };
   }
 });
 
 // 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";
+    init_runCli();
     searchGoogleTool = {
       definition: {
         name: "searchGoogle",
@@ -1142,24 +1136,10 @@ var init_searchGoogle = __esm({
       },
       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)");
-            }
-          );
-        });
+        return runCli(
+          `mindstudio search-google --query ${JSON.stringify(query)} --export-type json --output-key results --no-meta`,
+          { maxBuffer: 512 * 1024 }
+        );
       }
     };
   }
@@ -1516,7 +1496,7 @@ ${unifiedDiff(input.path, content, updated)}`;
 });
 
 // src/tools/code/bash.ts
-import { exec as exec4 } from "child_process";
+import { exec as exec2 } from "child_process";
 var DEFAULT_TIMEOUT_MS, DEFAULT_MAX_LINES3, bashTool;
 var init_bash = __esm({
   "src/tools/code/bash.ts"() {
@@ -1554,7 +1534,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) => {
-          exec4(
+          exec2(
             input.command,
             {
               timeout: timeoutMs,
@@ -1596,7 +1576,7 @@ var init_bash = __esm({
 });
 
 // src/tools/code/grep.ts
-import { exec as exec5 } from "child_process";
+import { exec as exec3 } from "child_process";
 function formatResults(stdout, max) {
   const lines = stdout.trim().split("\n");
   let result = lines.join("\n");
@@ -1647,12 +1627,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) => {
-          exec5(rgCmd, { maxBuffer: 512 * 1024 }, (err, stdout) => {
+          exec3(rgCmd, { maxBuffer: 512 * 1024 }, (err, stdout) => {
             if (stdout?.trim()) {
               resolve(formatResults(stdout, max));
               return;
             }
-            exec5(grepCmd, { maxBuffer: 512 * 1024 }, (_err, grepStdout) => {
+            exec3(grepCmd, { maxBuffer: 512 * 1024 }, (_err, grepStdout) => {
               if (grepStdout?.trim()) {
                 resolve(formatResults(grepStdout, max));
               } else {
@@ -1987,26 +1967,83 @@ var init_runMethod = __esm({
 });
 
 // src/tools/code/screenshot.ts
-var screenshotTool;
+var DEFAULT_PROMPT, screenshotTool;
 var init_screenshot = __esm({
   "src/tools/code/screenshot.ts"() {
     "use strict";
+    init_sidecar();
+    init_runCli();
+    DEFAULT_PROMPT = "Describe this app screenshot for a developer who cannot see it. What is visible on screen: the layout, content, interactive elements, any loading or error states. Be concise and factual.";
     screenshotTool = {
       definition: {
         name: "screenshot",
-        description: "Capture a screenshot of the app preview. Returns a CDN URL with dimensions. Useful for visually checking the current state after UI changes or when debugging layout issues.",
+        description: "Capture a screenshot of the app preview and get a description of what's on screen. Optionally provide a specific question about what you're looking for.",
         inputSchema: {
           type: "object",
-          properties: {}
+          properties: {
+            prompt: {
+              type: "string",
+              description: "Optional question about the screenshot. If omitted, returns a general description of what's visible."
+            }
+          }
         }
       },
-      async execute() {
-        return "ok";
+      async execute(input) {
+        try {
+          const { url } = await sidecarRequest(
+            "/screenshot",
+            {},
+            { timeout: 3e4 }
+          );
+          const analysisPrompt = input.prompt || DEFAULT_PROMPT;
+          const analysis = await runCli(
+            `mindstudio analyze-image --prompt ${JSON.stringify(analysisPrompt)} --image-url ${JSON.stringify(url)} --output-key analysis --no-meta`
+          );
+          return `Screenshot: ${url}
+
+${analysis}`;
+        } catch (err) {
+          return `Error taking screenshot: ${err.message}`;
+        }
       }
     };
   }
 });
 
+// src/subagents/common/cleanMessages.ts
+function cleanMessagesForApi(messages) {
+  return messages.map((msg) => {
+    if (!Array.isArray(msg.content)) {
+      return msg;
+    }
+    const blocks = msg.content;
+    const text = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+    const toolCalls = blocks.filter((b) => b.type === "tool").map((b) => ({ id: b.id, name: b.name, input: b.input }));
+    const thinking = blocks.filter(
+      (b) => b.type === "thinking"
+    ).map((b) => ({ thinking: b.thinking, signature: b.signature }));
+    const cleaned = {
+      role: msg.role,
+      content: text
+    };
+    if (toolCalls.length > 0) {
+      cleaned.toolCalls = toolCalls;
+    }
+    if (thinking.length > 0) {
+      cleaned.thinking = thinking;
+    }
+    if (msg.hidden) {
+      cleaned.hidden = true;
+    }
+    return cleaned;
+  });
+}
+var init_cleanMessages = __esm({
+  "src/subagents/common/cleanMessages.ts"() {
+    "use strict";
+  }
+});
+
 // src/subagents/runner.ts
 async function runSubAgent(config) {
   const {
@@ -2017,6 +2054,7 @@ async function runSubAgent(config) {
     executeTool: executeTool2,
     apiConfig,
     model,
+    subAgentId,
     signal,
     parentToolId,
     onEvent,
@@ -2028,17 +2066,18 @@ async function runSubAgent(config) {
   const messages = [{ role: "user", content: task }];
   while (true) {
     if (signal?.aborted) {
-      return "Error: cancelled";
+      return { text: "Error: cancelled", messages };
     }
-    let assistantText = "";
-    const toolCalls = [];
+    const contentBlocks = [];
+    let thinkingStartedAt = 0;
     let stopReason = "end_turn";
     try {
       for await (const event of streamChatWithRetry({
         ...apiConfig,
         model,
+        subAgentId,
         system,
-        messages,
+        messages: cleanMessagesForApi(messages),
         tools,
         signal
       })) {
@@ -2046,18 +2085,43 @@ async function runSubAgent(config) {
           break;
         }
         switch (event.type) {
-          case "text":
-            assistantText += event.text;
+          case "text": {
+            const lastBlock = contentBlocks.at(-1);
+            if (lastBlock?.type === "text") {
+              lastBlock.text += event.text;
+            } else {
+              contentBlocks.push({
+                type: "text",
+                text: event.text,
+                startedAt: event.ts
+              });
+            }
             emit2({ type: "text", text: event.text });
             break;
+          }
           case "thinking":
+            if (!thinkingStartedAt) {
+              thinkingStartedAt = event.ts;
+            }
             emit2({ type: "thinking", text: event.text });
             break;
+          case "thinking_complete":
+            contentBlocks.push({
+              type: "thinking",
+              thinking: event.thinking,
+              signature: event.signature,
+              startedAt: thinkingStartedAt,
+              completedAt: event.ts
+            });
+            thinkingStartedAt = 0;
+            break;
           case "tool_use":
-            toolCalls.push({
+            contentBlocks.push({
+              type: "tool",
               id: event.id,
               name: event.name,
-              input: event.input
+              input: event.input,
+              startedAt: Date.now()
             });
             emit2({
               type: "tool_start",
@@ -2070,7 +2134,7 @@ async function runSubAgent(config) {
             stopReason = event.stopReason;
             break;
           case "error":
-            return `Error: ${event.error}`;
+            return { text: `Error: ${event.error}`, messages };
         }
       }
     } catch (err) {
@@ -2079,15 +2143,18 @@ async function runSubAgent(config) {
       }
     }
     if (signal?.aborted) {
-      return "Error: cancelled";
+      return { text: "Error: cancelled", messages };
     }
     messages.push({
       role: "assistant",
-      content: assistantText,
-      toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+      content: contentBlocks
     });
+    const toolCalls = contentBlocks.filter(
+      (b) => b.type === "tool"
+    );
     if (stopReason !== "tool_use" || toolCalls.length === 0) {
-      return assistantText;
+      const text = contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+      return { text, messages };
     }
     log.info("Sub-agent executing tools", {
       parentToolId,
@@ -2143,6 +2210,7 @@ var init_runner = __esm({
     "use strict";
     init_api();
     init_logger();
+    init_cleanMessages();
   }
 });
 
@@ -2232,14 +2300,26 @@ var init_tools = __esm({
 // src/subagents/browserAutomation/prompt.ts
 import fs10 from "fs";
 import path4 from "path";
-var base, local, PROMPT_PATH, BROWSER_AUTOMATION_PROMPT;
+function getBrowserAutomationPrompt() {
+  try {
+    const appSpec = fs10.readFileSync("src/app.md", "utf-8").trim();
+    return `${BASE_PROMPT}
+
+<app_context>
+${appSpec}
+</app_context>`;
+  } catch {
+    return BASE_PROMPT;
+  }
+}
+var base, local, PROMPT_PATH, BASE_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();
+    BASE_PROMPT = fs10.readFileSync(PROMPT_PATH, "utf-8").trim();
   }
 });
 
@@ -2283,8 +2363,8 @@ var init_browserAutomation = __esm({
         } catch {
           return "Error: could not check browser status. The dev environment may not be running.";
         }
-        return runSubAgent({
-          system: BROWSER_AUTOMATION_PROMPT,
+        const result = await runSubAgent({
+          system: getBrowserAutomationPrompt(),
           task: input.task,
           tools: BROWSER_TOOLS,
           externalTools: BROWSER_EXTERNAL_TOOLS,
@@ -2301,39 +2381,40 @@ var init_browserAutomation = __esm({
           },
           apiConfig: context.apiConfig,
           model: context.model,
+          subAgentId: "browserAutomation",
           signal: context.signal,
           parentToolId: context.toolCallId,
           onEvent: context.onEvent,
           resolveExternalTool: context.resolveExternalTool
         });
+        context.subAgentMessages?.set(context.toolCallId, result.messages);
+        return result.text;
       }
     };
   }
 });
 
 // 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) {
+async function executeDesignExpertTool(name, input) {
   switch (name) {
+    case "screenshot": {
+      try {
+        const { url } = await sidecarRequest(
+          "/screenshot",
+          {},
+          { timeout: 3e4 }
+        );
+        const analysisPrompt = input.prompt || "Describe this app screenshot for a visual designer reviewing the current state. What is visible: layout, typography, colors, spacing, imagery. Note anything that looks broken or off. Be concise.";
+        const analysis = await runCli(
+          `mindstudio analyze-image --prompt ${JSON.stringify(analysisPrompt)} --image-url ${JSON.stringify(url)} --output-key analysis --no-meta`
+        );
+        return `Screenshot: ${url}
+
+${analysis}`;
+      } catch (err) {
+        return `Error taking screenshot: ${err.message}`;
+      }
+    }
     case "searchGoogle":
       return runCli(
         `mindstudio search-google --query ${JSON.stringify(input.query)} --export-type json --output-key results --no-meta`
@@ -2347,26 +2428,24 @@ async function executeDesignTool(name, input) {
         `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 ssUrl = await runCli(
-        `mindstudio screenshot-url --url ${JSON.stringify(input.url)} --mode viewport --width 1440 --delay 2000 --output-key screenshotUrl --no-meta`
-      );
-      if (ssUrl.startsWith("Error")) {
-        return `Could not screenshot ${input.url}: ${ssUrl}`;
-      }
+    case "analyzeReferenceImageOrUrl": {
+      const url = input.url;
       const analysisPrompt = input.prompt || DESIGN_REFERENCE_PROMPT;
+      const isImageUrl = /\.(png|jpe?g|webp|gif|svg|avif)(\?|$)/i.test(url);
+      let imageUrl = url;
+      if (!isImageUrl) {
+        const ssUrl = await runCli(
+          `mindstudio screenshot-url --url ${JSON.stringify(url)} --mode viewport --width 1440 --delay 2000 --output-key screenshotUrl --no-meta`
+        );
+        if (ssUrl.startsWith("Error")) {
+          return `Could not screenshot ${url}: ${ssUrl}`;
+        }
+        imageUrl = ssUrl;
+      }
       const analysis = await runCli(
-        `mindstudio analyze-image --prompt ${JSON.stringify(analysisPrompt)} --image-url ${JSON.stringify(ssUrl)} --no-meta`
+        `mindstudio analyze-image --prompt ${JSON.stringify(analysisPrompt)} --image-url ${JSON.stringify(imageUrl)} --output-key analysis --no-meta`
       );
-      return `Screenshot: ${ssUrl}
+      return isImageUrl ? analysis : `Screenshot: ${imageUrl}
 
 ${analysis}`;
     }
@@ -2380,6 +2459,8 @@ ${analysis}`;
       const prompts = input.prompts;
       const width = input.width || 2048;
       const height = input.height || 2048;
+      const ANALYZE_PROMPT = "You are reviewing this image for a visual designer sourcing assets for a project. Describe: what the image depicts, the mood and color palette, how the lighting and composition work, whether there are any issues (unwanted text, artifacts, distortions), and how it could be used in a layout (hero background, feature section, card texture, etc). Be concise and practical.";
+      let imageUrls;
       if (prompts.length === 1) {
         const step = JSON.stringify({
           prompt: prompts[0],
@@ -2388,30 +2469,58 @@ ${analysis}`;
             config: { width, height }
           }
         });
-        return runCli(
+        const url = await 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 }
+        imageUrls = [url];
+      } else {
+        const steps = prompts.map((prompt) => ({
+          stepType: "generateImage",
+          step: {
+            prompt,
+            imageModelOverride: {
+              model: "seedream-4.5",
+              config: { width, height }
+            }
           }
+        }));
+        const batchResult = await runCli(
+          `mindstudio batch '${JSON.stringify(steps)}' --no-meta`
+        );
+        try {
+          const parsed = JSON.parse(batchResult);
+          imageUrls = parsed.results.map(
+            (r) => r.output?.imageUrl ?? `Error: ${r.error}`
+          );
+        } catch {
+          return batchResult;
         }
-      }));
-      return runCli(`mindstudio batch '${JSON.stringify(steps)}' --no-meta`);
+      }
+      const analyses = await Promise.all(
+        imageUrls.map(async (url, i) => {
+          if (url.startsWith("Error")) {
+            return `Image ${i + 1}: ${url}`;
+          }
+          const analysis = await runCli(
+            `mindstudio analyze-image --prompt ${JSON.stringify(ANALYZE_PROMPT)} --image-url ${JSON.stringify(url)} --output-key analysis --no-meta`
+          );
+          return `**Image ${i + 1}:** ${url}
+Prompt: ${prompts[i]}
+Analysis: ${analysis}`;
+        })
+      );
+      return analyses.join("\n\n");
     }
     default:
       return `Error: unknown tool "${name}"`;
   }
 }
-var DESIGN_REFERENCE_PROMPT, DESIGN_RESEARCH_TOOLS;
+var DESIGN_REFERENCE_PROMPT, DESIGN_EXPERT_TOOLS;
 var init_tools2 = __esm({
   "src/subagents/designExpert/tools.ts"() {
     "use strict";
+    init_runCli();
+    init_sidecar();
     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
@@ -2419,7 +2528,7 @@ var init_tools2 = __esm({
 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 = [
+    DESIGN_EXPERT_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.",
@@ -2453,53 +2562,29 @@ Be specific and concise.`;
         }
       },
       {
-        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").',
+        name: "analyzeReferenceImageOrUrl",
+        description: "Analyze any visual \u2014 pass an image URL or a website URL. Websites are automatically screenshotted first. 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 instead.",
         inputSchema: {
           type: "object",
           properties: {
-            prompt: {
+            url: {
               type: "string",
-              description: "What to analyze or extract from the image."
+              description: "URL to analyze. Can be an image URL or a website URL (will be screenshotted)."
             },
-            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: {
+            prompt: {
               type: "string",
-              description: "URL of the screenshot or design image to analyze."
+              description: "Optional custom analysis prompt. If omitted, performs the standard design reference analysis."
             }
           },
-          required: ["imageUrl"]
+          required: ["url"]
         }
       },
       {
-        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.",
+        name: "screenshot",
+        description: "Capture a screenshot of the app preview. Returns a CDN URL. Use to review the current state of the UI being built.",
         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"]
+          properties: {}
         }
       },
       {
@@ -2518,7 +2603,7 @@ Be specific and concise.`;
       },
       {
         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.",
+        description: "Generate images using AI (Seedream). Returns CDN URLs with a quality analysis for each image. Produces high-quality results for both photorealistic images and abstract/creative visuals. Pass multiple prompts to generate in parallel. No need to analyze images separately after generating \u2014 the analysis is included.",
         inputSchema: {
           type: "object",
           properties: {
@@ -2545,19 +2630,120 @@ Be specific and concise.`;
   }
 });
 
-// src/subagents/designExpert/prompt.ts
+// src/subagents/common/context.ts
 import fs11 from "fs";
 import path5 from "path";
+function walkMdFiles(dir, skip) {
+  const files = [];
+  try {
+    for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
+      const full = path5.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!skip?.has(entry.name)) {
+          files.push(...walkMdFiles(full, skip));
+        }
+      } else if (entry.name.endsWith(".md")) {
+        files.push(full);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function loadFilesAsXml(dir, tag, skip) {
+  const files = walkMdFiles(dir, skip);
+  if (files.length === 0) {
+    return "";
+  }
+  const sections = files.map((f) => {
+    try {
+      const content = fs11.readFileSync(f, "utf-8").trim();
+      return `<file path="${f}">
+${content}
+</file>`;
+    } catch {
+      return "";
+    }
+  }).filter(Boolean);
+  return `<${tag}>
+${sections.join("\n\n")}
+</${tag}>`;
+}
+function loadSpecContext() {
+  return loadFilesAsXml("src", "spec_files", /* @__PURE__ */ new Set(["roadmap"]));
+}
+function loadRoadmapContext() {
+  return loadFilesAsXml("src/roadmap", "current_roadmap");
+}
+function loadPlatformBrief() {
+  return `<platform_brief>
+## What is a MindStudio app?
+
+A MindStudio app is a managed TypeScript project with three layers: a spec (natural language in src/), a backend contract (methods, tables, roles in dist/), and one or more interfaces (web, API, bots, cron, etc.). The spec is the source of truth; code is derived from it.
+
+## What people build
+
+- Business tools \u2014 dashboards, admin panels, approval workflows, data entry apps, internal tools with role-based access
+- AI-powered apps \u2014 chatbots, content generators, document processors, image/video tools, AI agents that take actions
+- Automations with no UI \u2014 cron jobs, webhook handlers, email processors, data sync pipelines
+- Bots \u2014 Discord slash-command bots, Telegram bots, MCP tool servers for AI assistants
+- Creative/interactive projects \u2014 games, interactive visualizations, generative art, portfolio sites
+- API services \u2014 backend logic exposed as REST endpoints
+- Simple static sites \u2014 no backend needed, just a web interface with a build step
+
+An app can be any combination of these.
+
+## Interfaces
+
+Each interface type invokes the same backend methods. Methods don't know which interface called them.
+
+- Web \u2014 any TypeScript project with a build command. Framework-agnostic (React, Vue, Svelte, vanilla, anything). The frontend SDK provides typed RPC to backend methods.
+- API \u2014 auto-generated REST endpoints for every method
+- Cron \u2014 scheduled jobs on a configurable interval
+- Webhook \u2014 HTTP endpoints that trigger methods
+- Discord \u2014 slash-command bots
+- Telegram \u2014 message-handling bots
+- Email \u2014 inbound email processing
+- MCP \u2014 tool servers for AI assistants
+
+## Backend
+
+TypeScript running in a sandboxed environment. Any npm package can be installed. Key capabilities:
+
+- Managed SQLite database with typed schemas and automatic migrations. Define a TypeScript interface, push, and the platform handles diffing and migrating.
+- Built-in role-based auth. Define roles in the manifest, gate methods with auth.requireRole(). Platform handles sessions, tokens, user resolution.
+- Sandboxed execution with npm packages pre-installed.
+- Git-native deployment. Push to default branch to deploy.
+
+## MindStudio SDK
+
+The first-party SDK (@mindstudio-ai/agent) provides access to 200+ AI models (OpenAI, Anthropic, Google, Meta, Mistral, and more) and 1000+ integrations (email, SMS, Slack, HubSpot, Google Workspace, web scraping, image/video generation, media processing, and much more) with zero configuration \u2014 credentials are handled automatically in the execution environment. No API keys needed.
+
+## What MindStudio apps are NOT good for
+
+- Native mobile apps (iOS/Android). Mobile-responsive web apps are fine.
+- Real-time multiplayer with persistent connections (no WebSocket support). Turn-based or async patterns work.
+</platform_brief>`;
+}
+var init_context = __esm({
+  "src/subagents/common/context.ts"() {
+    "use strict";
+  }
+});
+
+// src/subagents/designExpert/prompt.ts
+import fs12 from "fs";
+import path6 from "path";
 function resolvePath(filename) {
-  const local3 = path5.join(base2, filename);
-  return fs11.existsSync(local3) ? local3 : path5.join(base2, "subagents", "designExpert", filename);
+  const local4 = path6.join(base2, filename);
+  return fs12.existsSync(local4) ? local4 : path6.join(base2, "subagents", "designExpert", filename);
 }
 function readFile(filename) {
-  return fs11.readFileSync(resolvePath(filename), "utf-8").trim();
+  return fs12.readFileSync(resolvePath(filename), "utf-8").trim();
 }
 function readJson(filename, fallback) {
   try {
-    return JSON.parse(fs11.readFileSync(resolvePath(filename), "utf-8"));
+    return JSON.parse(fs12.readFileSync(resolvePath(filename), "utf-8"));
   } catch {
     return fallback;
   }
@@ -2573,7 +2759,7 @@ function sample(arr, n) {
   }
   return copy.slice(0, n);
 }
-function getDesignResearchPrompt() {
+function getDesignExpertPrompt() {
   const fonts = sample(fontData.fonts, 30);
   const pairings = sample(fontData.pairings, 20);
   const images = sample(inspirationImages, 15);
@@ -2612,16 +2798,24 @@ This is what the bar looks like. These are real sites that made it onto curated
 
 ${imageList}
 </inspiration_images>` : "";
-  return PROMPT_TEMPLATE.replace("{{fonts_to_consider}}", fontsSection).replace(
-    "{{inspiration_images}}",
-    inspirationSection
-  );
+  const specContext = loadSpecContext();
+  let prompt = PROMPT_TEMPLATE.replace(
+    "{{fonts_to_consider}}",
+    fontsSection
+  ).replace("{{inspiration_images}}", inspirationSection);
+  if (specContext) {
+    prompt += `
+
+${specContext}`;
+  }
+  return prompt;
 }
 var base2, RUNTIME_PLACEHOLDERS, PROMPT_TEMPLATE, fontData, inspirationImages;
 var init_prompt2 = __esm({
   "src/subagents/designExpert/prompt.ts"() {
     "use strict";
-    base2 = import.meta.dirname ?? path5.dirname(new URL(import.meta.url).pathname);
+    init_context();
+    base2 = import.meta.dirname ?? path6.dirname(new URL(import.meta.url).pathname);
     RUNTIME_PLACEHOLDERS = /* @__PURE__ */ new Set([
       "fonts_to_consider",
       "inspiration_images"
@@ -2650,23 +2844,7 @@ var init_designExpert = __esm({
     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 here rather than making those decisions yourself. This agent has curated font catalogs, color theory knowledge, access to design inspiration galleries, ability to create beautiful photos and images, 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)
-- Beautiful layout images or photos
-- Icon recommendations or AI image editing
-- Proposing full visual design and layout 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. If the user has any specific requirements, be sure to include them. The agent can not see your conversation with the user, so you need to include all details. 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.
+Visual design expert. Describe the situation and what you need \u2014 the agent decides what to deliver. It reads the spec files automatically. Include relevant user requirements and context it can't get from the spec, but do not list specific deliverables or tell it how to do its job.
 `.trim();
     designExpertTool = {
       definition: {
@@ -2685,105 +2863,38 @@ Concrete resources: hex values, font names with CSS URLs, image URLs, layout des
       },
       async execute(input, context) {
         if (!context) {
-          return "Error: design research requires execution context";
+          return "Error: visual design expert requires execution context";
         }
-        return runSubAgent({
-          system: getDesignResearchPrompt(),
+        const result = await runSubAgent({
+          system: getDesignExpertPrompt(),
           task: input.task,
-          tools: DESIGN_RESEARCH_TOOLS,
+          tools: DESIGN_EXPERT_TOOLS,
           externalTools: /* @__PURE__ */ new Set(),
-          executeTool: executeDesignTool,
+          executeTool: executeDesignExpertTool,
           apiConfig: context.apiConfig,
           model: context.model,
+          subAgentId: "visualDesignExpert",
           signal: context.signal,
           parentToolId: context.toolCallId,
           onEvent: context.onEvent,
           resolveExternalTool: context.resolveExternalTool
         });
+        context.subAgentMessages?.set(context.toolCallId, result.messages);
+        return result.text;
       }
     };
   }
 });
 
-// src/subagents/productVision/index.ts
-import fs12 from "fs";
-import path6 from "path";
-function loadSpecContext() {
-  const specDir = "src";
-  const files = [];
-  function walk(dir) {
-    try {
-      for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
-        const full = path6.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          if (entry.name !== "roadmap") {
-            walk(full);
-          }
-        } else if (entry.name.endsWith(".md")) {
-          files.push(full);
-        }
-      }
-    } catch {
-    }
-  }
-  walk(specDir);
-  if (files.length === 0) {
-    return "";
-  }
-  const sections = files.map((f) => {
-    try {
-      const content = fs12.readFileSync(f, "utf-8").trim();
-      return `<file path="${f}">
-${content}
-</file>`;
-    } catch {
-      return "";
-    }
-  }).filter(Boolean);
-  return `<spec_files>
-${sections.join("\n\n")}
-</spec_files>`;
-}
-async function executeVisionTool(name, input) {
-  if (name !== "writeRoadmapItem") {
-    return `Error: unknown tool "${name}"`;
-  }
-  const { slug, name: itemName, description, effort, requires, body } = input;
-  const dir = "src/roadmap";
-  const filePath = path6.join(dir, `${slug}.md`);
-  try {
-    fs12.mkdirSync(dir, { recursive: true });
-    const requiresYaml = requires.length === 0 ? "[]" : `[${requires.map((r) => `"${r}"`).join(", ")}]`;
-    const content = `---
-name: ${itemName}
-type: roadmap
-status: ${slug === "mvp" ? "in-progress" : "not-started"}
-description: ${description}
-effort: ${effort}
-requires: ${requiresYaml}
----
-
-${body}
-`;
-    fs12.writeFileSync(filePath, content, "utf-8");
-    return `Wrote ${filePath}`;
-  } catch (err) {
-    return `Error writing ${filePath}: ${err.message}`;
-  }
-}
-var base3, local2, PROMPT_PATH2, BASE_PROMPT, VISION_TOOLS, productVisionTool;
-var init_productVision = __esm({
-  "src/subagents/productVision/index.ts"() {
+// src/subagents/productVision/tools.ts
+var VISION_TOOLS;
+var init_tools3 = __esm({
+  "src/subagents/productVision/tools.ts"() {
     "use strict";
-    init_runner();
-    base3 = import.meta.dirname ?? path6.dirname(new URL(import.meta.url).pathname);
-    local2 = path6.join(base3, "prompt.md");
-    PROMPT_PATH2 = fs12.existsSync(local2) ? local2 : path6.join(base3, "subagents", "productVision", "prompt.md");
-    BASE_PROMPT = fs12.readFileSync(PROMPT_PATH2, "utf-8").trim();
     VISION_TOOLS = [
       {
         name: "writeRoadmapItem",
-        description: "Write a roadmap item to src/roadmap/. Call this once for each idea.",
+        description: "Create a new roadmap item in src/roadmap/.",
         inputSchema: {
           type: "object",
           properties: {
@@ -2810,23 +2921,250 @@ var init_productVision = __esm({
             },
             body: {
               type: "string",
-              description: "Full MSFM body: prose description for the user, followed by ~~~annotation~~~ with technical implementation notes for the building agent."
+              description: "Full MSFM body: prose description for the user, followed by ~~~annotation~~~ with technical implementation notes."
             }
           },
           required: ["slug", "name", "description", "effort", "requires", "body"]
         }
+      },
+      {
+        name: "updateRoadmapItem",
+        description: "Update an existing roadmap item. Only include the fields you want to change.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: {
+              type: "string",
+              description: "The slug of the item to update (filename without .md)."
+            },
+            status: {
+              type: "string",
+              enum: ["done", "in-progress", "not-started"],
+              description: "New status."
+            },
+            name: {
+              type: "string",
+              description: "Updated feature name."
+            },
+            description: {
+              type: "string",
+              description: "Updated summary."
+            },
+            effort: {
+              type: "string",
+              enum: ["quick", "small", "medium", "large"],
+              description: "Updated effort level."
+            },
+            requires: {
+              type: "array",
+              items: { type: "string" },
+              description: "Updated prerequisites."
+            },
+            body: {
+              type: "string",
+              description: "Full replacement body (overwrites existing body)."
+            },
+            appendHistory: {
+              type: "string",
+              description: 'A history entry to append. Format: "- **2026-03-22** \u2014 Description of what was done."'
+            }
+          },
+          required: ["slug"]
+        }
+      },
+      {
+        name: "deleteRoadmapItem",
+        description: "Remove a roadmap item. Use when an idea is no longer relevant or has been absorbed into another item.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: {
+              type: "string",
+              description: "The slug of the item to delete (filename without .md)."
+            }
+          },
+          required: ["slug"]
+        }
       }
     ];
+  }
+});
+
+// src/subagents/productVision/executor.ts
+import fs13 from "fs";
+import path7 from "path";
+function formatRequires(requires) {
+  return requires.length === 0 ? "[]" : `[${requires.map((r) => `"${r}"`).join(", ")}]`;
+}
+async function executeVisionTool(name, input) {
+  switch (name) {
+    case "writeRoadmapItem": {
+      const {
+        slug,
+        name: itemName,
+        description,
+        effort,
+        requires,
+        body
+      } = input;
+      const filePath = path7.join(ROADMAP_DIR, `${slug}.md`);
+      try {
+        fs13.mkdirSync(ROADMAP_DIR, { recursive: true });
+        const content = `---
+name: ${itemName}
+type: roadmap
+status: ${slug === "mvp" ? "in-progress" : "not-started"}
+description: ${description}
+effort: ${effort}
+requires: ${formatRequires(requires)}
+---
+
+${body}
+`;
+        fs13.writeFileSync(filePath, content, "utf-8");
+        return `Wrote ${filePath}`;
+      } catch (err) {
+        return `Error writing ${filePath}: ${err.message}`;
+      }
+    }
+    case "updateRoadmapItem": {
+      const { slug } = input;
+      const filePath = path7.join(ROADMAP_DIR, `${slug}.md`);
+      try {
+        if (!fs13.existsSync(filePath)) {
+          return `Error: ${filePath} does not exist`;
+        }
+        let content = fs13.readFileSync(filePath, "utf-8");
+        if (input.status) {
+          content = content.replace(
+            /^status:\s*.+$/m,
+            `status: ${input.status}`
+          );
+        }
+        if (input.name) {
+          content = content.replace(/^name:\s*.+$/m, `name: ${input.name}`);
+        }
+        if (input.description) {
+          content = content.replace(
+            /^description:\s*.+$/m,
+            `description: ${input.description}`
+          );
+        }
+        if (input.effort) {
+          content = content.replace(
+            /^effort:\s*.+$/m,
+            `effort: ${input.effort}`
+          );
+        }
+        if (input.requires) {
+          content = content.replace(
+            /^requires:\s*.+$/m,
+            `requires: ${formatRequires(input.requires)}`
+          );
+        }
+        if (input.body) {
+          const endOfFrontmatter = content.indexOf("---", 4);
+          if (endOfFrontmatter !== -1) {
+            const frontmatter = content.slice(0, endOfFrontmatter + 3);
+            content = `${frontmatter}
+
+${input.body}
+`;
+          }
+        }
+        if (input.appendHistory) {
+          if (content.includes("## History")) {
+            content = content.trimEnd() + `
+${input.appendHistory}
+`;
+          } else {
+            content = content.trimEnd() + `
+
+## History
+
+${input.appendHistory}
+`;
+          }
+        }
+        fs13.writeFileSync(filePath, content, "utf-8");
+        return `Updated ${filePath}`;
+      } catch (err) {
+        return `Error updating ${filePath}: ${err.message}`;
+      }
+    }
+    case "deleteRoadmapItem": {
+      const { slug } = input;
+      const filePath = path7.join(ROADMAP_DIR, `${slug}.md`);
+      try {
+        if (!fs13.existsSync(filePath)) {
+          return `Error: ${filePath} does not exist`;
+        }
+        fs13.unlinkSync(filePath);
+        return `Deleted ${filePath}`;
+      } catch (err) {
+        return `Error deleting ${filePath}: ${err.message}`;
+      }
+    }
+    default:
+      return `Error: unknown tool "${name}"`;
+  }
+}
+var ROADMAP_DIR;
+var init_executor = __esm({
+  "src/subagents/productVision/executor.ts"() {
+    "use strict";
+    init_context();
+    ROADMAP_DIR = "src/roadmap";
+  }
+});
+
+// src/subagents/productVision/prompt.ts
+import fs14 from "fs";
+import path8 from "path";
+function getProductVisionPrompt() {
+  const specContext = loadSpecContext();
+  const roadmapContext = loadRoadmapContext();
+  const parts = [BASE_PROMPT2, loadPlatformBrief()];
+  if (specContext) {
+    parts.push(specContext);
+  }
+  if (roadmapContext) {
+    parts.push(roadmapContext);
+  }
+  return parts.join("\n\n");
+}
+var base3, local2, PROMPT_PATH2, BASE_PROMPT2;
+var init_prompt3 = __esm({
+  "src/subagents/productVision/prompt.ts"() {
+    "use strict";
+    init_executor();
+    init_context();
+    base3 = import.meta.dirname ?? path8.dirname(new URL(import.meta.url).pathname);
+    local2 = path8.join(base3, "prompt.md");
+    PROMPT_PATH2 = fs14.existsSync(local2) ? local2 : path8.join(base3, "subagents", "productVision", "prompt.md");
+    BASE_PROMPT2 = fs14.readFileSync(PROMPT_PATH2, "utf-8").trim();
+  }
+});
+
+// src/subagents/productVision/index.ts
+var productVisionTool;
+var init_productVision = __esm({
+  "src/subagents/productVision/index.ts"() {
+    "use strict";
+    init_runner();
+    init_tools3();
+    init_executor();
+    init_prompt3();
     productVisionTool = {
       definition: {
         name: "productVision",
-        description: `A product visionary that imagines where the project could go next. It automatically reads all spec files from src/ for context. Pass a brief description of the app and who it's for. It generates 10-15 ambitious, creative roadmap ideas and writes them directly to src/roadmap/. Use this at the end of spec authoring to populate the roadmap.`,
+        description: "Owns the product roadmap. Reads spec and roadmap files automatically. Creates, updates, and deletes roadmap items in src/roadmap/. Describe the situation and what needs to happen.",
         inputSchema: {
           type: "object",
           properties: {
             task: {
               type: "string",
-              description: "Brief description of the app and who it's for. The tool reads the full spec files automatically \u2014 no need to repeat their contents."
+              description: "What to do with the roadmap. Include relevant context. The tool reads spec and roadmap files automatically."
             }
           },
           required: ["task"]
@@ -2836,23 +3174,180 @@ var init_productVision = __esm({
         if (!context) {
           return "Error: product vision requires execution context";
         }
-        const specContext = loadSpecContext();
-        const system = specContext ? `${BASE_PROMPT}
-
-${specContext}` : BASE_PROMPT;
-        return runSubAgent({
-          system,
+        const result = await runSubAgent({
+          system: getProductVisionPrompt(),
           task: input.task,
           tools: VISION_TOOLS,
           externalTools: /* @__PURE__ */ new Set(),
           executeTool: executeVisionTool,
           apiConfig: context.apiConfig,
           model: context.model,
+          subAgentId: "productVision",
+          signal: context.signal,
+          parentToolId: context.toolCallId,
+          onEvent: context.onEvent,
+          resolveExternalTool: context.resolveExternalTool
+        });
+        context.subAgentMessages?.set(context.toolCallId, result.messages);
+        return result.text;
+      }
+    };
+  }
+});
+
+// src/subagents/codeSanityCheck/tools.ts
+var SANITY_CHECK_TOOLS;
+var init_tools4 = __esm({
+  "src/subagents/codeSanityCheck/tools.ts"() {
+    "use strict";
+    SANITY_CHECK_TOOLS = [
+      {
+        name: "readFile",
+        description: "Read a file from the project.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "File path relative to project root."
+            }
+          },
+          required: ["path"]
+        }
+      },
+      {
+        name: "grep",
+        description: "Search file contents for a pattern.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pattern: { type: "string", description: "Search pattern (regex)." },
+            path: {
+              type: "string",
+              description: "Directory or file to search in."
+            }
+          },
+          required: ["pattern"]
+        }
+      },
+      {
+        name: "glob",
+        description: "Find files by glob pattern.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pattern: {
+              type: "string",
+              description: 'Glob pattern (e.g., "src/**/*.ts").'
+            }
+          },
+          required: ["pattern"]
+        }
+      },
+      {
+        name: "searchGoogle",
+        description: "Search the web. Use to verify packages are current or find alternatives.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query." }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "fetchUrl",
+        description: "Fetch a web page as markdown. Use to read package docs, changelogs, npm pages.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            url: { type: "string", description: "URL to fetch." }
+          },
+          required: ["url"]
+        }
+      },
+      {
+        name: "askMindStudioSdk",
+        description: "Check if the MindStudio SDK has a managed action for something before writing custom code.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "What you want to check." }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "bash",
+        description: "Run a shell command. Use for reading/search/etc operations only.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            command: { type: "string", description: "The command to run." }
+          },
+          required: ["command"]
+        }
+      }
+    ];
+  }
+});
+
+// src/subagents/codeSanityCheck/index.ts
+import fs15 from "fs";
+import path9 from "path";
+var base4, local3, PROMPT_PATH3, BASE_PROMPT3, codeSanityCheckTool;
+var init_codeSanityCheck = __esm({
+  "src/subagents/codeSanityCheck/index.ts"() {
+    "use strict";
+    init_runner();
+    init_context();
+    init_tools5();
+    init_tools4();
+    base4 = import.meta.dirname ?? path9.dirname(new URL(import.meta.url).pathname);
+    local3 = path9.join(base4, "prompt.md");
+    PROMPT_PATH3 = fs15.existsSync(local3) ? local3 : path9.join(base4, "subagents", "codeSanityCheck", "prompt.md");
+    BASE_PROMPT3 = fs15.readFileSync(PROMPT_PATH3, "utf-8").trim();
+    codeSanityCheckTool = {
+      definition: {
+        name: "codeSanityCheck",
+        description: 'Quick sanity check on an approach before building. Reviews architecture, package choices, and flags potential issues. Usually responds with "looks good." Occasionally catches something important. Readonly \u2014 can search the web and read code but cannot modify anything.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            task: {
+              type: "string",
+              description: "What you're about to build and how. Include the plan, packages you intend to use, and any architectural decisions you've made."
+            }
+          },
+          required: ["task"]
+        }
+      },
+      async execute(input, context) {
+        if (!context) {
+          return "Error: code sanity check requires execution context";
+        }
+        const specContext = loadSpecContext();
+        const parts = [BASE_PROMPT3, loadPlatformBrief()];
+        if (specContext) {
+          parts.push(specContext);
+        }
+        const system = parts.join("\n\n");
+        const result = await runSubAgent({
+          system,
+          task: input.task,
+          tools: SANITY_CHECK_TOOLS,
+          externalTools: /* @__PURE__ */ new Set(),
+          executeTool: (name, toolInput) => executeTool(name, toolInput, context),
+          apiConfig: context.apiConfig,
+          model: context.model,
+          subAgentId: "codeSanityCheck",
           signal: context.signal,
           parentToolId: context.toolCallId,
           onEvent: context.onEvent,
           resolveExternalTool: context.resolveExternalTool
         });
+        context.subAgentMessages?.set(context.toolCallId, result.messages);
+        return result.text;
       }
     };
   }
@@ -2892,7 +3387,8 @@ function getCommonTools() {
     searchGoogleTool,
     setProjectNameTool,
     designExpertTool,
-    productVisionTool
+    productVisionTool,
+    codeSanityCheckTool
   ];
 }
 function getPostOnboardingTools() {
@@ -2937,7 +3433,7 @@ function executeTool(name, input, context) {
   }
   return tool.execute(input, context);
 }
-var init_tools3 = __esm({
+var init_tools5 = __esm({
   "src/tools/index.ts"() {
     "use strict";
     init_readSpec();
@@ -2951,7 +3447,7 @@ var init_tools3 = __esm({
     init_setProjectOnboardingState();
     init_promptUser();
     init_confirmDestructiveAction();
-    init_askMindStudioSdk();
+    init_sdkConsultant();
     init_fetchUrl();
     init_searchGoogle();
     init_setProjectName();
@@ -2972,14 +3468,15 @@ var init_tools3 = __esm({
     init_browserAutomation();
     init_designExpert();
     init_productVision();
+    init_codeSanityCheck();
   }
 });
 
 // src/session.ts
-import fs13 from "fs";
+import fs16 from "fs";
 function loadSession(state) {
   try {
-    const raw = fs13.readFileSync(SESSION_FILE, "utf-8");
+    const raw = fs16.readFileSync(SESSION_FILE, "utf-8");
     const data = JSON.parse(raw);
     if (Array.isArray(data.messages) && data.messages.length > 0) {
       state.messages = sanitizeMessages(data.messages);
@@ -2994,7 +3491,13 @@ function sanitizeMessages(messages) {
   for (let i = 0; i < messages.length; i++) {
     result.push(messages[i]);
     const msg = messages[i];
-    if (msg.role !== "assistant" || !msg.toolCalls?.length) {
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) {
+      continue;
+    }
+    const toolBlocks = msg.content.filter(
+      (b) => b.type === "tool"
+    );
+    if (toolBlocks.length === 0) {
       continue;
     }
     const resultIds = /* @__PURE__ */ new Set();
@@ -3006,7 +3509,7 @@ function sanitizeMessages(messages) {
         break;
       }
     }
-    for (const tc of msg.toolCalls) {
+    for (const tc of toolBlocks) {
       if (!resultIds.has(tc.id)) {
         result.push({
           role: "user",
@@ -3021,7 +3524,7 @@ function sanitizeMessages(messages) {
 }
 function saveSession(state) {
   try {
-    fs13.writeFileSync(
+    fs16.writeFileSync(
       SESSION_FILE,
       JSON.stringify({ messages: state.messages }, null, 2),
       "utf-8"
@@ -3032,7 +3535,7 @@ function saveSession(state) {
 function clearSession(state) {
   state.messages = [];
   try {
-    fs13.unlinkSync(SESSION_FILE);
+    fs16.unlinkSync(SESSION_FILE);
   } catch {
   }
 }
@@ -3329,6 +3832,14 @@ var init_errors = __esm({
 });
 
 // src/agent.ts
+function getTextContent(blocks) {
+  return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+}
+function getToolCalls(blocks) {
+  return blocks.filter(
+    (b) => b.type === "tool"
+  );
+}
 function createAgentState() {
   return { messages: [] };
 }
@@ -3370,6 +3881,12 @@ async function runTurn(params) {
     });
   }
   state.messages.push(userMsg);
+  const STATUS_EXCLUDED_TOOLS = /* @__PURE__ */ new Set([
+    "setProjectOnboardingState",
+    "setProjectName",
+    "clearSyncStatus",
+    "editsFinished"
+  ]);
   let lastCompletedTools = "";
   let lastCompletedResult = "";
   while (true) {
@@ -3387,8 +3904,8 @@ async function runTurn(params) {
       saveSession(state);
       return;
     }
-    let assistantText = "";
-    const toolCalls = [];
+    const contentBlocks = [];
+    let thinkingStartedAt = 0;
     const toolInputAccumulators = /* @__PURE__ */ new Map();
     let stopReason = "end_turn";
     async function handlePartialInput(acc, id, name, partial) {
@@ -3457,8 +3974,8 @@ async function runTurn(params) {
     const statusWatcher = startStatusWatcher({
       apiConfig,
       getContext: () => ({
-        assistantText: assistantText.slice(-500),
-        lastToolName: toolCalls.at(-1)?.name || lastCompletedTools || void 0,
+        assistantText: getTextContent(contentBlocks).slice(-500),
+        lastToolName: getToolCalls(contentBlocks).filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).at(-1)?.name || lastCompletedTools || void 0,
         lastToolResult: lastCompletedResult || void 0
       }),
       onStatus: (label) => onEvent({ type: "status", message: label }),
@@ -3470,7 +3987,7 @@ async function runTurn(params) {
           ...apiConfig,
           model,
           system,
-          messages: state.messages,
+          messages: cleanMessagesForApi(state.messages),
           tools,
           signal
         },
@@ -3487,13 +4004,36 @@ async function runTurn(params) {
           break;
         }
         switch (event.type) {
-          case "text":
-            assistantText += event.text;
+          case "text": {
+            const lastBlock = contentBlocks.at(-1);
+            if (lastBlock?.type === "text") {
+              lastBlock.text += event.text;
+            } else {
+              contentBlocks.push({
+                type: "text",
+                text: event.text,
+                startedAt: event.ts
+              });
+            }
             onEvent({ type: "text", text: event.text });
             break;
+          }
           case "thinking":
+            if (!thinkingStartedAt) {
+              thinkingStartedAt = event.ts;
+            }
             onEvent({ type: "thinking", text: event.text });
             break;
+          case "thinking_complete":
+            contentBlocks.push({
+              type: "thinking",
+              thinking: event.thinking,
+              signature: event.signature,
+              startedAt: thinkingStartedAt,
+              completedAt: event.ts
+            });
+            thinkingStartedAt = 0;
+            break;
           case "tool_input_delta": {
             const acc = getOrCreateAccumulator2(event.id, event.name);
             acc.json += event.delta;
@@ -3521,10 +4061,12 @@ async function runTurn(params) {
             break;
           }
           case "tool_use": {
-            toolCalls.push({
+            contentBlocks.push({
+              type: "tool",
               id: event.id,
               name: event.name,
-              input: event.input
+              input: event.input,
+              startedAt: event.ts
             });
             const acc = toolInputAccumulators.get(event.id);
             const tool = getToolByName(event.name);
@@ -3563,11 +4105,15 @@ async function runTurn(params) {
       statusWatcher.stop();
     }
     if (signal?.aborted) {
-      if (assistantText) {
+      if (contentBlocks.length > 0) {
+        contentBlocks.push({
+          type: "text",
+          text: "\n\n(cancelled)",
+          startedAt: Date.now()
+        });
         state.messages.push({
           role: "assistant",
-          content: assistantText + "\n\n(cancelled)",
-          toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+          content: [...contentBlocks].sort((a, b) => a.startedAt - b.startedAt)
         });
       }
       onEvent({ type: "turn_cancelled" });
@@ -3576,9 +4122,9 @@ async function runTurn(params) {
     }
     state.messages.push({
       role: "assistant",
-      content: assistantText,
-      toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+      content: [...contentBlocks].sort((a, b) => a.startedAt - b.startedAt)
     });
+    const toolCalls = getToolCalls(contentBlocks);
     if (stopReason !== "tool_use" || toolCalls.length === 0) {
       saveSession(state);
       onEvent({ type: "turn_done" });
@@ -3588,6 +4134,29 @@ async function runTurn(params) {
       count: toolCalls.length,
       tools: toolCalls.map((tc) => tc.name)
     });
+    let subAgentText = "";
+    const origOnEvent = onEvent;
+    const wrappedOnEvent = (e) => {
+      if ("parentToolId" in e && e.parentToolId) {
+        if (e.type === "text") {
+          subAgentText = e.text;
+        } else if (e.type === "tool_start") {
+          subAgentText = `Using ${e.name}`;
+        }
+      }
+      origOnEvent(e);
+    };
+    const toolStatusWatcher = startStatusWatcher({
+      apiConfig,
+      getContext: () => ({
+        assistantText: subAgentText || getTextContent(contentBlocks).slice(-500),
+        lastToolName: toolCalls.filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).map((tc) => tc.name).join(", ") || void 0,
+        lastToolResult: lastCompletedResult || void 0
+      }),
+      onStatus: (label) => origOnEvent({ type: "status", message: label }),
+      signal
+    });
+    const subAgentMessages = /* @__PURE__ */ new Map();
     const results = await Promise.all(
       toolCalls.map(async (tc) => {
         if (signal?.aborted) {
@@ -3612,9 +4181,10 @@ async function runTurn(params) {
               apiConfig,
               model,
               signal,
-              onEvent,
+              onEvent: wrappedOnEvent,
               resolveExternalTool,
-              toolCallId: tc.id
+              toolCallId: tc.id,
+              subAgentMessages
             });
           }
           const isError = result.startsWith("Error");
@@ -3645,7 +4215,21 @@ async function runTurn(params) {
         }
       })
     );
-    lastCompletedTools = toolCalls.map((tc) => tc.name).join(", ");
+    toolStatusWatcher.stop();
+    for (const r of results) {
+      const block = contentBlocks.find(
+        (b) => b.type === "tool" && b.id === r.id
+      );
+      if (block?.type === "tool") {
+        block.result = r.result;
+        block.isError = r.isError;
+        const msgs = subAgentMessages.get(r.id);
+        if (msgs) {
+          block.subAgentMessages = msgs;
+        }
+      }
+    }
+    lastCompletedTools = toolCalls.filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).map((tc) => tc.name).join(", ");
     lastCompletedResult = results.at(-1)?.result ?? "";
     for (const r of results) {
       state.messages.push({
@@ -3667,12 +4251,13 @@ var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
     init_api();
-    init_tools3();
+    init_tools5();
     init_session();
     init_logger();
     init_parsePartialJson();
     init_statusWatcher();
     init_errors();
+    init_cleanMessages();
     EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
       "promptUser",
       "setProjectOnboardingState",
@@ -3684,19 +4269,18 @@ var init_agent = __esm({
       "runScenario",
       "runMethod",
       "browserCommand",
-      "screenshot",
       "setProjectName"
     ]);
   }
 });
 
 // src/prompt/static/projectContext.ts
-import fs14 from "fs";
-import path7 from "path";
+import fs17 from "fs";
+import path10 from "path";
 function loadProjectInstructions() {
   for (const file of AGENT_INSTRUCTION_FILES) {
     try {
-      const content = fs14.readFileSync(file, "utf-8").trim();
+      const content = fs17.readFileSync(file, "utf-8").trim();
       if (content) {
         return `
 ## Project Instructions (${file})
@@ -3709,7 +4293,7 @@ ${content}`;
 }
 function loadProjectManifest() {
   try {
-    const manifest = fs14.readFileSync("mindstudio.json", "utf-8");
+    const manifest = fs17.readFileSync("mindstudio.json", "utf-8");
     return `
 ## Project Manifest (mindstudio.json)
 \`\`\`json
@@ -3721,7 +4305,7 @@ ${manifest}
 }
 function loadSpecFileMetadata() {
   try {
-    const files = walkMdFiles("src");
+    const files = walkMdFiles2("src");
     if (files.length === 0) {
       return "";
     }
@@ -3747,14 +4331,14 @@ ${entries.join("\n")}`;
     return "";
   }
 }
-function walkMdFiles(dir) {
+function walkMdFiles2(dir) {
   const results = [];
   try {
-    const entries = fs14.readdirSync(dir, { withFileTypes: true });
+    const entries = fs17.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path7.join(dir, entry.name);
+      const full = path10.join(dir, entry.name);
       if (entry.isDirectory()) {
-        results.push(...walkMdFiles(full));
+        results.push(...walkMdFiles2(full));
       } else if (entry.name.endsWith(".md")) {
         results.push(full);
       }
@@ -3765,7 +4349,7 @@ function walkMdFiles(dir) {
 }
 function parseFrontmatter(filePath) {
   try {
-    const content = fs14.readFileSync(filePath, "utf-8");
+    const content = fs17.readFileSync(filePath, "utf-8");
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) {
       return { name: "", description: "", type: "" };
@@ -3781,7 +4365,7 @@ function parseFrontmatter(filePath) {
 }
 function loadProjectFileListing() {
   try {
-    const entries = fs14.readdirSync(".", { withFileTypes: true });
+    const entries = fs17.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;
@@ -3824,12 +4408,12 @@ var init_projectContext = __esm({
 });
 
 // src/prompt/index.ts
-import fs15 from "fs";
-import path8 from "path";
+import fs18 from "fs";
+import path11 from "path";
 function requireFile(filePath) {
-  const full = path8.join(PROMPT_DIR, filePath);
+  const full = path11.join(PROMPT_DIR, filePath);
   try {
-    return fs15.readFileSync(full, "utf-8").trim();
+    return fs18.readFileSync(full, "utf-8").trim();
   } catch {
     throw new Error(`Required prompt file missing: ${full}`);
   }
@@ -3919,6 +4503,8 @@ ${projectContext}
 {{static/authoring.md}}
 </spec_authoring_instructions>
 
+{{static/team.md}}
+
 <code_authoring_instructions>
 {{static/coding.md}}
 ${isLspConfigured() ? `<typescript_lsp>
@@ -3949,22 +4535,22 @@ ${viewContext?.activeFile ? `Active file: ${viewContext.activeFile}` : ""}
   return resolveIncludes(template);
 }
 var PROMPT_DIR;
-var init_prompt3 = __esm({
+var init_prompt4 = __esm({
   "src/prompt/index.ts"() {
     "use strict";
     init_lsp();
     init_projectContext();
-    PROMPT_DIR = import.meta.dirname ?? path8.dirname(new URL(import.meta.url).pathname);
+    PROMPT_DIR = import.meta.dirname ?? path11.dirname(new URL(import.meta.url).pathname);
   }
 });
 
 // src/config.ts
-import fs16 from "fs";
-import path9 from "path";
+import fs19 from "fs";
+import path12 from "path";
 import os from "os";
 function loadConfigFile() {
   try {
-    const raw = fs16.readFileSync(CONFIG_PATH, "utf-8");
+    const raw = fs19.readFileSync(CONFIG_PATH, "utf-8");
     log.debug("Loaded config file", { path: CONFIG_PATH });
     return JSON.parse(raw);
   } catch (err) {
@@ -4000,7 +4586,7 @@ var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_logger();
-    CONFIG_PATH = path9.join(
+    CONFIG_PATH = path12.join(
       os.homedir(),
       ".mindstudio-local-tunnel",
       "config.json"
@@ -4015,10 +4601,10 @@ __export(headless_exports, {
   startHeadless: () => startHeadless
 });
 import { createInterface } from "readline";
-import fs17 from "fs";
-import path10 from "path";
+import fs20 from "fs";
+import path13 from "path";
 function loadActionPrompt(name) {
-  return fs17.readFileSync(path10.join(ACTIONS_DIR, `${name}.md`), "utf-8").trim();
+  return fs20.readFileSync(path13.join(ACTIONS_DIR, `${name}.md`), "utf-8").trim();
 }
 function emit(event, data) {
   process.stdout.write(JSON.stringify({ event, ...data }) + "\n");
@@ -4106,19 +4692,27 @@ async function startHeadless(opts = {}) {
         break;
     }
   }
-  function resolveExternalTool(id, _name, _input) {
+  const USER_FACING_TOOLS = /* @__PURE__ */ new Set([
+    "promptUser",
+    "confirmDestructiveAction",
+    "presentPlan",
+    "presentSyncPlan",
+    "presentPublishPlan"
+  ]);
+  function resolveExternalTool(id, name, _input) {
     const early = earlyResults.get(id);
     if (early !== void 0) {
       earlyResults.delete(id);
       return Promise.resolve(early);
     }
+    const shouldTimeout = !USER_FACING_TOOLS.has(name);
     return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
+      const timeout = shouldTimeout ? setTimeout(() => {
         pendingTools.delete(id);
         resolve(
           "Error: Tool timed out \u2014 no response from the app environment after 5 minutes."
         );
-      }, EXTERNAL_TOOL_TIMEOUT_MS);
+      }, EXTERNAL_TOOL_TIMEOUT_MS) : void 0;
       pendingTools.set(id, {
         resolve: (result) => {
           clearTimeout(timeout);
@@ -4233,20 +4827,20 @@ var init_headless = __esm({
   "src/headless.ts"() {
     "use strict";
     init_config();
-    init_prompt3();
+    init_prompt4();
     init_lsp();
     init_agent();
     init_session();
-    BASE_DIR = import.meta.dirname ?? path10.dirname(new URL(import.meta.url).pathname);
-    ACTIONS_DIR = path10.join(BASE_DIR, "actions");
+    BASE_DIR = import.meta.dirname ?? path13.dirname(new URL(import.meta.url).pathname);
+    ACTIONS_DIR = path13.join(BASE_DIR, "actions");
   }
 });
 
 // src/index.tsx
 import { render } from "ink";
 import os2 from "os";
-import fs18 from "fs";
-import path11 from "path";
+import fs21 from "fs";
+import path14 from "path";
 
 // src/tui/App.tsx
 import { useState as useState2, useCallback, useRef } from "react";
@@ -4381,7 +4975,7 @@ function MessageList({ turns }) {
 
 // src/tui/App.tsx
 init_agent();
-init_prompt3();
+init_prompt4();
 init_session();
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 function App({ apiConfig, model }) {
@@ -4563,8 +5157,8 @@ for (let i = 0; i < args.length; i++) {
 }
 function printDebugInfo(config) {
   const pkg = JSON.parse(
-    fs18.readFileSync(
-      path11.join(import.meta.dirname, "..", "package.json"),
+    fs21.readFileSync(
+      path14.join(import.meta.dirname, "..", "package.json"),
       "utf-8"
     )
   );