@mindstudio-ai/remy 0.1.19 → 0.1.21

package/dist/headless.js

@@ -1,7 +1,7 @@
 // src/headless.ts
 import { createInterface } from "readline";
-import fs17 from "fs";
-import path10 from "path";
+import fs20 from "fs";
+import path13 from "path";
 
 // src/config.ts
 import fs2 from "fs";
@@ -371,6 +371,8 @@ ${projectContext}
 {{static/authoring.md}}
 </spec_authoring_instructions>
 
+{{static/team.md}}
+
 <code_authoring_instructions>
 {{static/coding.md}}
 ${isLspConfigured() ? `<typescript_lsp>
@@ -1240,19 +1242,36 @@ var confirmDestructiveActionTool = {
   }
 };
 
-// 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)");
+      }
+    );
+  });
+}
+
+// src/subagents/sdkConsultant/index.ts
 var 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: {
@@ -1266,28 +1285,13 @@ 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
     });
   }
 };
 
 // src/tools/common/fetchUrl.ts
-import { exec as exec2 } from "child_process";
 var fetchUrlTool = {
   definition: {
     name: "scapeWebUrl",
@@ -1314,29 +1318,13 @@ var fetchUrlTool = {
     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 = {
   definition: {
     name: "searchGoogle",
@@ -1354,24 +1342,10 @@ var searchGoogleTool = {
   },
   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 }
+    );
   }
 };
 
@@ -1696,7 +1670,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 = 12e4;
 var DEFAULT_MAX_LINES3 = 500;
 var bashTool = {
@@ -1730,7 +1704,7 @@ var bashTool = {
     const maxLines = input.maxLines === 0 ? Infinity : input.maxLines || DEFAULT_MAX_LINES3;
     const timeoutMs = input.timeout ? input.timeout * 1e3 : DEFAULT_TIMEOUT_MS;
     return new Promise((resolve) => {
-      exec4(
+      exec2(
         input.command,
         {
           timeout: timeoutMs,
@@ -1770,7 +1744,7 @@ var bashTool = {
 };
 
 // src/tools/code/grep.ts
-import { exec as exec5 } from "child_process";
+import { exec as exec3 } from "child_process";
 var DEFAULT_MAX = 50;
 function formatResults(stdout, max) {
   const lines = stdout.trim().split("\n");
@@ -1817,12 +1791,12 @@ var grepTool = {
     const rgCmd = `rg -n --no-heading --max-count=${max}${globFlag} '${escaped}' ${searchPath}`;
     const grepCmd = `grep -rn --max-count=${max} '${escaped}' ${searchPath} --include='*.ts' --include='*.tsx' --include='*.js' --include='*.json' --include='*.md'`;
     return new Promise((resolve) => {
-      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 {
@@ -2054,20 +2028,70 @@ var runMethodTool = {
 };
 
 // src/tools/code/screenshot.ts
+var 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.";
 var 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;
+  });
+}
+
 // src/subagents/runner.ts
 async function runSubAgent(config) {
   const {
@@ -2078,6 +2102,7 @@ async function runSubAgent(config) {
     executeTool: executeTool2,
     apiConfig,
     model,
+    subAgentId,
     signal,
     parentToolId,
     onEvent,
@@ -2089,17 +2114,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
       })) {
@@ -2107,18 +2133,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",
@@ -2131,7 +2182,7 @@ async function runSubAgent(config) {
             stopReason = event.stopReason;
             break;
           case "error":
-            return `Error: ${event.error}`;
+            return { text: `Error: ${event.error}`, messages };
         }
       }
     } catch (err) {
@@ -2140,15 +2191,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,
@@ -2283,7 +2337,19 @@ import path7 from "path";
 var base = import.meta.dirname ?? path7.dirname(new URL(import.meta.url).pathname);
 var local = path7.join(base, "prompt.md");
 var PROMPT_PATH = fs13.existsSync(local) ? local : path7.join(base, "subagents", "browserAutomation", "prompt.md");
-var BROWSER_AUTOMATION_PROMPT = fs13.readFileSync(PROMPT_PATH, "utf-8").trim();
+var BASE_PROMPT = fs13.readFileSync(PROMPT_PATH, "utf-8").trim();
+function getBrowserAutomationPrompt() {
+  try {
+    const appSpec = fs13.readFileSync("src/app.md", "utf-8").trim();
+    return `${BASE_PROMPT}
+
+<app_context>
+${appSpec}
+</app_context>`;
+  } catch {
+    return BASE_PROMPT;
+  }
+}
 
 // src/subagents/browserAutomation/index.ts
 var browserAutomationTool = {
@@ -2317,8 +2383,8 @@ var browserAutomationTool = {
     } 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,
@@ -2335,16 +2401,18 @@ var browserAutomationTool = {
       },
       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";
 var DESIGN_REFERENCE_PROMPT = `Analyze this website/app screenshot as a design reference. Assess:
 1) Mood/aesthetic
 2) Color palette with approximate hex values and palette strategy
@@ -2352,7 +2420,7 @@ var DESIGN_REFERENCE_PROMPT = `Analyze this website/app screenshot as a design r
 4) Layout composition (symmetric/asymmetric, grid structure, whitespace usage, content density)
 5) What makes it distinctive and interesting vs generic AI-generated interfaces
 Be specific and concise.`;
-var DESIGN_RESEARCH_TOOLS = [
+var 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.",
@@ -2386,53 +2454,29 @@ var DESIGN_RESEARCH_TOOLS = [
     }
   },
   {
-    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: {}
     }
   },
   {
@@ -2451,7 +2495,7 @@ var DESIGN_RESEARCH_TOOLS = [
   },
   {
     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: {
@@ -2475,27 +2519,26 @@ var DESIGN_RESEARCH_TOOLS = [
     }
   }
 ];
-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`
@@ -2509,26 +2552,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}`;
     }
@@ -2542,6 +2583,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],
@@ -2550,21 +2593,47 @@ ${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}"`;
@@ -2572,19 +2641,117 @@ ${analysis}`;
 }
 
 // src/subagents/designExpert/prompt.ts
+import fs15 from "fs";
+import path9 from "path";
+
+// src/subagents/common/context.ts
 import fs14 from "fs";
 import path8 from "path";
-var base2 = import.meta.dirname ?? path8.dirname(new URL(import.meta.url).pathname);
+function walkMdFiles2(dir, skip) {
+  const files = [];
+  try {
+    for (const entry of fs14.readdirSync(dir, { withFileTypes: true })) {
+      const full = path8.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!skip?.has(entry.name)) {
+          files.push(...walkMdFiles2(full, skip));
+        }
+      } else if (entry.name.endsWith(".md")) {
+        files.push(full);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function loadFilesAsXml(dir, tag, skip) {
+  const files = walkMdFiles2(dir, skip);
+  if (files.length === 0) {
+    return "";
+  }
+  const sections = files.map((f) => {
+    try {
+      const content = fs14.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>`;
+}
+
+// src/subagents/designExpert/prompt.ts
+var base2 = import.meta.dirname ?? path9.dirname(new URL(import.meta.url).pathname);
 function resolvePath(filename) {
-  const local3 = path8.join(base2, filename);
-  return fs14.existsSync(local3) ? local3 : path8.join(base2, "subagents", "designExpert", filename);
+  const local4 = path9.join(base2, filename);
+  return fs15.existsSync(local4) ? local4 : path9.join(base2, "subagents", "designExpert", filename);
 }
 function readFile(filename) {
-  return fs14.readFileSync(resolvePath(filename), "utf-8").trim();
+  return fs15.readFileSync(resolvePath(filename), "utf-8").trim();
 }
 function readJson(filename, fallback) {
   try {
-    return JSON.parse(fs14.readFileSync(resolvePath(filename), "utf-8"));
+    return JSON.parse(fs15.readFileSync(resolvePath(filename), "utf-8"));
   } catch {
     return fallback;
   }
@@ -2616,7 +2783,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);
@@ -2655,31 +2822,22 @@ 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;
 }
 
 // src/subagents/designExpert/index.ts
 var DESCRIPTION = `
-A dedicated visual design expert. You have a lot on your plate as a coding agent, and design is a specialized skill \u2014 delegate visual design 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();
 var designExpertTool = {
   definition: {
@@ -2698,71 +2856,32 @@ var designExpertTool = {
   },
   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 fs15 from "fs";
-import path9 from "path";
-var base3 = import.meta.dirname ?? path9.dirname(new URL(import.meta.url).pathname);
-var local2 = path9.join(base3, "prompt.md");
-var PROMPT_PATH2 = fs15.existsSync(local2) ? local2 : path9.join(base3, "subagents", "productVision", "prompt.md");
-var BASE_PROMPT = fs15.readFileSync(PROMPT_PATH2, "utf-8").trim();
-function loadSpecContext() {
-  const specDir = "src";
-  const files = [];
-  function walk(dir) {
-    try {
-      for (const entry of fs15.readdirSync(dir, { withFileTypes: true })) {
-        const full = path9.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 = fs15.readFileSync(f, "utf-8").trim();
-      return `<file path="${f}">
-${content}
-</file>`;
-    } catch {
-      return "";
-    }
-  }).filter(Boolean);
-  return `<spec_files>
-${sections.join("\n\n")}
-</spec_files>`;
-}
+// src/subagents/productVision/tools.ts
 var 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: {
@@ -2789,50 +2908,225 @@ var VISION_TOOLS = [
         },
         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 fs16 from "fs";
+import path10 from "path";
+var ROADMAP_DIR = "src/roadmap";
+function formatRequires(requires) {
+  return requires.length === 0 ? "[]" : `[${requires.map((r) => `"${r}"`).join(", ")}]`;
+}
 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 = path9.join(dir, `${slug}.md`);
-  try {
-    fs15.mkdirSync(dir, { recursive: true });
-    const requiresYaml = requires.length === 0 ? "[]" : `[${requires.map((r) => `"${r}"`).join(", ")}]`;
-    const content = `---
+  switch (name) {
+    case "writeRoadmapItem": {
+      const {
+        slug,
+        name: itemName,
+        description,
+        effort,
+        requires,
+        body
+      } = input;
+      const filePath = path10.join(ROADMAP_DIR, `${slug}.md`);
+      try {
+        fs16.mkdirSync(ROADMAP_DIR, { recursive: true });
+        const content = `---
 name: ${itemName}
 type: roadmap
 status: ${slug === "mvp" ? "in-progress" : "not-started"}
 description: ${description}
 effort: ${effort}
-requires: ${requiresYaml}
+requires: ${formatRequires(requires)}
 ---
 
 ${body}
 `;
-    fs15.writeFileSync(filePath, content, "utf-8");
-    return `Wrote ${filePath}`;
-  } catch (err) {
-    return `Error writing ${filePath}: ${err.message}`;
+        fs16.writeFileSync(filePath, content, "utf-8");
+        return `Wrote ${filePath}`;
+      } catch (err) {
+        return `Error writing ${filePath}: ${err.message}`;
+      }
+    }
+    case "updateRoadmapItem": {
+      const { slug } = input;
+      const filePath = path10.join(ROADMAP_DIR, `${slug}.md`);
+      try {
+        if (!fs16.existsSync(filePath)) {
+          return `Error: ${filePath} does not exist`;
+        }
+        let content = fs16.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}
+`;
+          }
+        }
+        fs16.writeFileSync(filePath, content, "utf-8");
+        return `Updated ${filePath}`;
+      } catch (err) {
+        return `Error updating ${filePath}: ${err.message}`;
+      }
+    }
+    case "deleteRoadmapItem": {
+      const { slug } = input;
+      const filePath = path10.join(ROADMAP_DIR, `${slug}.md`);
+      try {
+        if (!fs16.existsSync(filePath)) {
+          return `Error: ${filePath} does not exist`;
+        }
+        fs16.unlinkSync(filePath);
+        return `Deleted ${filePath}`;
+      } catch (err) {
+        return `Error deleting ${filePath}: ${err.message}`;
+      }
+    }
+    default:
+      return `Error: unknown tool "${name}"`;
   }
 }
+
+// src/subagents/productVision/prompt.ts
+import fs17 from "fs";
+import path11 from "path";
+var base3 = import.meta.dirname ?? path11.dirname(new URL(import.meta.url).pathname);
+var local2 = path11.join(base3, "prompt.md");
+var PROMPT_PATH2 = fs17.existsSync(local2) ? local2 : path11.join(base3, "subagents", "productVision", "prompt.md");
+var BASE_PROMPT2 = fs17.readFileSync(PROMPT_PATH2, "utf-8").trim();
+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");
+}
+
+// src/subagents/productVision/index.ts
 var 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"]
@@ -2842,23 +3136,166 @@ var productVisionTool = {
     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/index.ts
+import fs18 from "fs";
+import path12 from "path";
+
+// src/subagents/codeSanityCheck/tools.ts
+var 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
+var base4 = import.meta.dirname ?? path12.dirname(new URL(import.meta.url).pathname);
+var local3 = path12.join(base4, "prompt.md");
+var PROMPT_PATH3 = fs18.existsSync(local3) ? local3 : path12.join(base4, "subagents", "codeSanityCheck", "prompt.md");
+var BASE_PROMPT3 = fs18.readFileSync(PROMPT_PATH3, "utf-8").trim();
+var 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;
   }
 };
 
@@ -2896,7 +3333,8 @@ function getCommonTools() {
     searchGoogleTool,
     setProjectNameTool,
     designExpertTool,
-    productVisionTool
+    productVisionTool,
+    codeSanityCheckTool
   ];
 }
 function getPostOnboardingTools() {
@@ -2943,11 +3381,11 @@ function executeTool(name, input, context) {
 }
 
 // src/session.ts
-import fs16 from "fs";
+import fs19 from "fs";
 var SESSION_FILE = ".remy-session.json";
 function loadSession(state) {
   try {
-    const raw = fs16.readFileSync(SESSION_FILE, "utf-8");
+    const raw = fs19.readFileSync(SESSION_FILE, "utf-8");
     const data = JSON.parse(raw);
     if (Array.isArray(data.messages) && data.messages.length > 0) {
       state.messages = sanitizeMessages(data.messages);
@@ -2962,7 +3400,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();
@@ -2974,7 +3418,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",
@@ -2989,7 +3433,7 @@ function sanitizeMessages(messages) {
 }
 function saveSession(state) {
   try {
-    fs16.writeFileSync(
+    fs19.writeFileSync(
       SESSION_FILE,
       JSON.stringify({ messages: state.messages }, null, 2),
       "utf-8"
@@ -3000,7 +3444,7 @@ function saveSession(state) {
 function clearSession(state) {
   state.messages = [];
   try {
-    fs16.unlinkSync(SESSION_FILE);
+    fs19.unlinkSync(SESSION_FILE);
   } catch {
   }
 }
@@ -3272,6 +3716,14 @@ function friendlyError(raw) {
 }
 
 // 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"
+  );
+}
 var EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "promptUser",
   "setProjectOnboardingState",
@@ -3283,7 +3735,6 @@ var EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "runScenario",
   "runMethod",
   "browserCommand",
-  "screenshot",
   "setProjectName"
 ]);
 function createAgentState() {
@@ -3327,6 +3778,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) {
@@ -3344,8 +3801,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) {
@@ -3414,8 +3871,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 }),
@@ -3427,7 +3884,7 @@ async function runTurn(params) {
           ...apiConfig,
           model,
           system,
-          messages: state.messages,
+          messages: cleanMessagesForApi(state.messages),
           tools,
           signal
         },
@@ -3444,13 +3901,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;
@@ -3478,10 +3958,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);
@@ -3520,11 +4002,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" });
@@ -3533,9 +4019,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" });
@@ -3545,6 +4031,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) {
@@ -3569,9 +4078,10 @@ async function runTurn(params) {
               apiConfig,
               model,
               signal,
-              onEvent,
+              onEvent: wrappedOnEvent,
               resolveExternalTool,
-              toolCallId: tc.id
+              toolCallId: tc.id,
+              subAgentMessages
             });
           }
           const isError = result.startsWith("Error");
@@ -3602,7 +4112,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({
@@ -3621,10 +4145,10 @@ async function runTurn(params) {
 }
 
 // src/headless.ts
-var BASE_DIR = import.meta.dirname ?? path10.dirname(new URL(import.meta.url).pathname);
-var ACTIONS_DIR = path10.join(BASE_DIR, "actions");
+var BASE_DIR = import.meta.dirname ?? path13.dirname(new URL(import.meta.url).pathname);
+var ACTIONS_DIR = path13.join(BASE_DIR, "actions");
 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");
@@ -3712,19 +4236,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);