@mindstudio-ai/remy 0.1.34 → 0.1.36

package/dist/index.js

@@ -1057,7 +1057,12 @@ function runCli(cmd, options) {
           const entry = JSON.parse(trimmed);
           if (entry.type === "log" && entry.value) {
             const prefix = entry.tag ? `[${entry.tag}]` : "[log]";
-            logs.push(`${prefix} ${entry.value}`);
+            const formatted = `${prefix} ${entry.value}`;
+            if (options?.onLog) {
+              options.onLog(formatted);
+            } else {
+              logs.push(formatted);
+            }
           }
         } catch {
         }
@@ -1069,7 +1074,7 @@ function runCli(cmd, options) {
     }, timeout);
     child.on("close", (code) => {
       clearTimeout(timer);
-      const logBlock = logs.length > 0 ? logs.join("\n") + "\n\n" : "";
+      const logBlock = !options?.onLog && logs.length > 0 ? logs.join("\n") + "\n\n" : "";
       const out = stdout.trim();
       if (out) {
         resolve(logBlock + out);
@@ -1111,11 +1116,12 @@ var init_sdkConsultant = __esm({
           required: ["query"]
         }
       },
-      async execute(input) {
+      async execute(input, context) {
         const query = input.query;
         return runCli(`mindstudio ask ${JSON.stringify(query)}`, {
           timeout: 2e5,
-          maxBuffer: 512 * 1024
+          maxBuffer: 512 * 1024,
+          onLog: context?.onLog
         });
       }
     };
@@ -1147,7 +1153,7 @@ var init_fetchUrl = __esm({
           required: ["url"]
         }
       },
-      async execute(input) {
+      async execute(input, context) {
         const url = input.url;
         const screenshot = input.screenshot;
         const pageOptions = { onlyMainContent: true };
@@ -1155,7 +1161,8 @@ var init_fetchUrl = __esm({
           pageOptions.screenshot = true;
         }
         return runCli(
-          `mindstudio scrape-url --url ${JSON.stringify(url)} --page-options ${JSON.stringify(JSON.stringify(pageOptions))} --no-meta`
+          `mindstudio scrape-url --url ${JSON.stringify(url)} --page-options ${JSON.stringify(JSON.stringify(pageOptions))} --no-meta`,
+          { onLog: context?.onLog }
         );
       }
     };
@@ -1183,11 +1190,11 @@ var init_searchGoogle = __esm({
           required: ["query"]
         }
       },
-      async execute(input) {
+      async execute(input, context) {
         const query = input.query;
         return runCli(
           `mindstudio search-google --query ${JSON.stringify(query)} --export-type json --output-key results --no-meta`,
-          { maxBuffer: 512 * 1024 }
+          { maxBuffer: 512 * 1024, onLog: context?.onLog }
         );
       }
     };
@@ -1224,9 +1231,9 @@ var init_setProjectName = __esm({
 // src/tools/code/readFile.ts
 import fs6 from "fs/promises";
 function isBinary(buffer) {
-  const sample2 = buffer.subarray(0, 8192);
-  for (let i = 0; i < sample2.length; i++) {
-    if (sample2[i] === 0) {
+  const sample3 = buffer.subarray(0, 8192);
+  for (let i = 0; i < sample3.length; i++) {
+    if (sample3[i] === 0) {
       return true;
     }
   }
@@ -2018,18 +2025,16 @@ var init_runMethod = __esm({
 // src/tools/_helpers/screenshot.ts
 async function captureAndAnalyzeScreenshot(promptOrOptions) {
   let prompt;
-  let fullPage = false;
+  let onLog;
   if (typeof promptOrOptions === "object" && promptOrOptions !== null) {
     prompt = promptOrOptions.prompt;
-    fullPage = promptOrOptions.fullPage ?? false;
+    onLog = promptOrOptions.onLog;
   } else {
     prompt = promptOrOptions;
   }
-  const ssResult = await sidecarRequest(
-    "/screenshot",
-    { fullPage },
-    { timeout: 12e4 }
-  );
+  const ssResult = await sidecarRequest("/screenshot-full-page", void 0, {
+    timeout: 12e4
+  });
   log.debug("Screenshot response", { ssResult });
   const url = ssResult?.url || ssResult?.screenshotUrl;
   if (!url) {
@@ -2043,7 +2048,7 @@ async function captureAndAnalyzeScreenshot(promptOrOptions) {
   const analysisPrompt = prompt || SCREENSHOT_ANALYSIS_PROMPT;
   const analysis = await runCli(
     `mindstudio analyze-image --prompt ${JSON.stringify(analysisPrompt)} --image-url ${JSON.stringify(url)} --output-key analysis --no-meta`,
-    { timeout: 2e5 }
+    { timeout: 2e5, onLog }
   );
   return JSON.stringify({ url, analysis });
 }
@@ -2054,7 +2059,7 @@ var init_screenshot = __esm({
     init_sidecar();
     init_runCli();
     init_logger();
-    SCREENSHOT_ANALYSIS_PROMPT = "Describe everything visible on screen from top to bottom \u2014 every element, its position, its size relative to the viewport, its colors, its content. Be thorough and spatial. After the inventory, note anything that looks visually broken (overlapping elements, clipped text, misaligned components).";
+    SCREENSHOT_ANALYSIS_PROMPT = "Describe everything visible on screen from top to bottom \u2014 every element, its position, its size relative to the viewport, its colors, its content. Be comprehensive, thorough, and spatial. After the inventory, note anything that looks visually broken (overlapping elements, clipped text, misaligned components). Respond only with your analysis as Markdown and absolutely no other text. Do not use emojis - use unicode if you need symbols.";
   }
 });
 
@@ -2067,26 +2072,22 @@ var init_screenshot2 = __esm({
     screenshotTool = {
       definition: {
         name: "screenshot",
-        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. By default captures the viewport (what the user sees). Set fullPage to capture the entire scrollable page.",
+        description: "Capture a full-height 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: {
             prompt: {
               type: "string",
               description: "Optional question about the screenshot. If omitted, returns a general description of what's visible."
-            },
-            fullPage: {
-              type: "boolean",
-              description: "Capture the full scrollable page instead of just the viewport. Use when you need to see below-the-fold content."
             }
           }
         }
       },
-      async execute(input) {
+      async execute(input, context) {
         try {
           return await captureAndAnalyzeScreenshot({
             prompt: input.prompt,
-            fullPage: input.fullPage
+            onLog: context?.onLog
           });
         } catch (err) {
           return `Error taking screenshot: ${err.message}`;
@@ -2096,6 +2097,91 @@ var init_screenshot2 = __esm({
   }
 });
 
+// src/statusWatcher.ts
+function startStatusWatcher(config) {
+  const { apiConfig, getContext, onStatus, interval = 3e3, signal } = config;
+  let lastLabel = "";
+  let inflight = false;
+  let stopped = false;
+  const url = `${apiConfig.baseUrl}/_internal/v2/agent/remy/generate-status`;
+  async function tick() {
+    if (stopped || signal?.aborted || inflight) {
+      return;
+    }
+    inflight = true;
+    try {
+      const ctx = getContext();
+      if (!ctx.assistantText && !ctx.lastToolName) {
+        log.debug("Status watcher: no context, skipping");
+        return;
+      }
+      log.debug("Status watcher: requesting label", {
+        textLength: ctx.assistantText.length,
+        lastToolName: ctx.lastToolName
+      });
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiConfig.apiKey}`
+        },
+        body: JSON.stringify({
+          assistantText: ctx.assistantText.slice(-500),
+          lastToolName: ctx.lastToolName,
+          lastToolResult: ctx.lastToolResult?.slice(-200),
+          onboardingState: ctx.onboardingState,
+          userMessage: ctx.userMessage?.slice(-200)
+        }),
+        signal
+      });
+      if (!res.ok) {
+        log.debug("Status watcher: endpoint returned non-ok", {
+          status: res.status
+        });
+        return;
+      }
+      const data = await res.json();
+      if (!data.label) {
+        log.debug("Status watcher: no label in response");
+        return;
+      }
+      if (data.label === lastLabel) {
+        log.debug("Status watcher: duplicate label, skipping", {
+          label: data.label
+        });
+        return;
+      }
+      lastLabel = data.label;
+      if (stopped) {
+        return;
+      }
+      log.debug("Status watcher: emitting", { label: data.label });
+      onStatus(data.label);
+    } catch (err) {
+      log.debug("Status watcher: error", { error: err?.message ?? "unknown" });
+    } finally {
+      inflight = false;
+    }
+  }
+  const timer = setInterval(tick, interval);
+  tick().catch(() => {
+  });
+  log.debug("Status watcher started", { interval });
+  return {
+    stop() {
+      stopped = true;
+      clearInterval(timer);
+      log.debug("Status watcher stopped");
+    }
+  };
+}
+var init_statusWatcher = __esm({
+  "src/statusWatcher.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
 // src/subagents/common/cleanMessages.ts
 function cleanMessagesForApi(messages) {
   return messages.map((msg) => {
@@ -2135,7 +2221,7 @@ async function runSubAgent(config) {
   const {
     system,
     task,
-    tools,
+    tools: tools2,
     externalTools,
     executeTool: executeTool2,
     apiConfig,
@@ -2144,19 +2230,47 @@ async function runSubAgent(config) {
     signal,
     parentToolId,
     onEvent,
-    resolveExternalTool
+    resolveExternalTool,
+    toolRegistry
   } = config;
   const emit2 = (e) => {
     onEvent({ ...e, parentToolId });
   };
   const messages = [{ role: "user", content: task }];
+  function getPartialText(blocks) {
+    return blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+  }
+  function abortResult(blocks) {
+    if (signal?.reason === "graceful") {
+      const partial = getPartialText(blocks);
+      return {
+        text: partial ? `[INTERRUPTED]
+
+${partial}` : "[INTERRUPTED] Sub-agent was interrupted before producing output.",
+        messages
+      };
+    }
+    return { text: "Error: cancelled", messages };
+  }
+  let lastToolResult = "";
   while (true) {
     if (signal?.aborted) {
-      return { text: "Error: cancelled", messages };
+      return abortResult([]);
     }
     const contentBlocks = [];
     let thinkingStartedAt = 0;
     let stopReason = "end_turn";
+    let currentToolNames = "";
+    const statusWatcher = startStatusWatcher({
+      apiConfig,
+      getContext: () => ({
+        assistantText: getPartialText(contentBlocks),
+        lastToolName: currentToolNames || void 0,
+        lastToolResult: lastToolResult || void 0
+      }),
+      onStatus: (label) => emit2({ type: "status", message: label }),
+      signal
+    });
     const fullSystem = `${system}
 
 Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}`;
@@ -2167,7 +2281,7 @@ Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " "
         subAgentId,
         system: fullSystem,
         messages: cleanMessagesForApi(messages),
-        tools,
+        tools: tools2,
         signal
       })) {
         if (signal?.aborted) {
@@ -2232,7 +2346,8 @@ Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " "
       }
     }
     if (signal?.aborted) {
-      return { text: "Error: cancelled", messages };
+      statusWatcher.stop();
+      return abortResult(contentBlocks);
     }
     messages.push({
       role: "assistant",
@@ -2242,6 +2357,7 @@ Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " "
       (b) => b.type === "tool"
     );
     if (stopReason !== "tool_use" || toolCalls.length === 0) {
+      statusWatcher.stop();
       const text = contentBlocks.filter((b) => b.type === "text").map((b) => b.text).join("");
       return { text, messages };
     }
@@ -2250,40 +2366,82 @@ Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " "
       count: toolCalls.length,
       tools: toolCalls.map((tc) => tc.name)
     });
+    currentToolNames = toolCalls.map((tc) => tc.name).join(", ");
     const results = await Promise.all(
       toolCalls.map(async (tc) => {
         if (signal?.aborted) {
           return { id: tc.id, result: "Error: cancelled", isError: true };
         }
-        try {
-          let result;
-          if (externalTools.has(tc.name) && resolveExternalTool) {
-            result = await resolveExternalTool(tc.id, tc.name, tc.input);
-          } else {
-            result = await executeTool2(tc.name, tc.input, tc.id);
+        let settle;
+        const resultPromise = new Promise((res) => {
+          settle = (result, isError) => res({ id: tc.id, result, isError });
+        });
+        let toolAbort = new AbortController();
+        const cascadeAbort = () => toolAbort.abort();
+        signal?.addEventListener("abort", cascadeAbort, { once: true });
+        let settled = false;
+        const safeSettle = (result, isError) => {
+          if (settled) {
+            return;
           }
-          const isError = result.startsWith("Error");
-          emit2({
-            type: "tool_done",
-            id: tc.id,
-            name: tc.name,
-            result,
-            isError
-          });
-          return { id: tc.id, result, isError };
-        } catch (err) {
-          const errorMsg = `Error: ${err.message}`;
-          emit2({
-            type: "tool_done",
-            id: tc.id,
-            name: tc.name,
-            result: errorMsg,
-            isError: true
-          });
-          return { id: tc.id, result: errorMsg, isError: true };
-        }
+          settled = true;
+          signal?.removeEventListener("abort", cascadeAbort);
+          settle(result, isError);
+        };
+        const run = async (input) => {
+          try {
+            let result;
+            if (externalTools.has(tc.name) && resolveExternalTool) {
+              result = await resolveExternalTool(tc.id, tc.name, input);
+            } else {
+              const onLog = (line) => emit2({
+                type: "tool_input_delta",
+                id: tc.id,
+                name: tc.name,
+                result: line
+              });
+              result = await executeTool2(tc.name, input, tc.id, onLog);
+            }
+            safeSettle(result, result.startsWith("Error"));
+          } catch (err) {
+            safeSettle(`Error: ${err.message}`, true);
+          }
+        };
+        const entry = {
+          id: tc.id,
+          name: tc.name,
+          input: tc.input,
+          parentToolId,
+          abortController: toolAbort,
+          startedAt: Date.now(),
+          settle: safeSettle,
+          rerun: (newInput) => {
+            settled = false;
+            toolAbort = new AbortController();
+            signal?.addEventListener("abort", () => toolAbort.abort(), {
+              once: true
+            });
+            entry.abortController = toolAbort;
+            entry.input = newInput;
+            run(newInput);
+          }
+        };
+        toolRegistry?.register(entry);
+        run(tc.input);
+        const r = await resultPromise;
+        toolRegistry?.unregister(tc.id);
+        emit2({
+          type: "tool_done",
+          id: tc.id,
+          name: tc.name,
+          result: r.result,
+          isError: r.isError
+        });
+        return r;
       })
     );
+    statusWatcher.stop();
+    lastToolResult = results.at(-1)?.result ?? "";
     for (const r of results) {
       const block = contentBlocks.find(
         (b) => b.type === "tool" && b.id === r.id
@@ -2291,6 +2449,7 @@ Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " "
       if (block?.type === "tool") {
         block.result = r.result;
         block.isError = r.isError;
+        block.completedAt = Date.now();
       }
       messages.push({
         role: "user",
@@ -2306,6 +2465,7 @@ var init_runner = __esm({
     "use strict";
     init_api();
     init_logger();
+    init_statusWatcher();
     init_cleanMessages();
   }
 });
@@ -2340,7 +2500,7 @@ var init_tools = __esm({
                       "styles",
                       "screenshot"
                     ],
-                    description: "snapshot: accessibility tree of the page (waits for network to settle). click: click an element (animated cursor, full event sequence). type: type text into input (one char at a time, works with React/Vue/Svelte). select: select a dropdown option by text. wait: wait for an element to appear (polls 100ms, waits for network). navigate: navigate to a URL within the app (waits for load, subsequent steps run on new page). evaluate: run JS in the page. styles: read computed CSS styles from elements (pass properties array with camelCase names, or omit for defaults). screenshot: full-page viewport-stitched screenshot (returns base64 JPEG with dimensions)."
+                    description: "snapshot: accessibility tree of the page (waits for network to settle). click: click an element (animated cursor, full event sequence). type: type text into input (one char at a time, works with React/Vue/Svelte). select: select a dropdown option by text. wait: wait for an element to appear (polls 100ms, waits for network). navigate: navigate to a URL within the app (waits for load, subsequent steps run on new page). evaluate: run JS in the page. styles: read computed CSS styles from elements (pass properties array with camelCase names, or omit for defaults). screenshot: full-page viewport-stitched screenshot (returns CDN url with dimensions)."
                   },
                   ref: {
                     type: "string",
@@ -2396,8 +2556,8 @@ var init_tools = __esm({
         }
       },
       {
-        name: "screenshot",
-        description: "Capture a screenshot of the current page. Returns a CDN URL with dimensions.",
+        name: "screenshotFullPage",
+        description: "Capture a full-height screenshot of the current page. Returns a CDN URL with full text analysis and description.",
         inputSchema: {
           type: "object",
           properties: {}
@@ -2416,12 +2576,54 @@ var init_tools = __esm({
   }
 });
 
-// src/subagents/browserAutomation/prompt.ts
+// src/assets.ts
 import fs10 from "fs";
 import path4 from "path";
+function findRoot(start) {
+  let dir = start;
+  while (dir !== path4.dirname(dir)) {
+    if (fs10.existsSync(path4.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = path4.dirname(dir);
+  }
+  return start;
+}
+function assetPath(...segments) {
+  return path4.join(ASSETS_BASE, ...segments);
+}
+function readAsset(...segments) {
+  const full = assetPath(...segments);
+  try {
+    return fs10.readFileSync(full, "utf-8").trim();
+  } catch {
+    throw new Error(`Required asset missing: ${full}`);
+  }
+}
+function readJsonAsset(fallback, ...segments) {
+  const full = assetPath(...segments);
+  try {
+    return JSON.parse(fs10.readFileSync(full, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+var ROOT, ASSETS_BASE;
+var init_assets = __esm({
+  "src/assets.ts"() {
+    "use strict";
+    ROOT = findRoot(
+      import.meta.dirname ?? path4.dirname(new URL(import.meta.url).pathname)
+    );
+    ASSETS_BASE = fs10.existsSync(path4.join(ROOT, "dist", "prompt")) ? path4.join(ROOT, "dist") : path4.join(ROOT, "src");
+  }
+});
+
+// src/subagents/browserAutomation/prompt.ts
+import fs11 from "fs";
 function getBrowserAutomationPrompt() {
   try {
-    const appSpec = fs10.readFileSync("src/app.md", "utf-8").trim();
+    const appSpec = fs11.readFileSync("src/app.md", "utf-8").trim();
     return `${BASE_PROMPT}
 
 <app_context>
@@ -2431,14 +2633,12 @@ ${appSpec}
     return BASE_PROMPT;
   }
 }
-var base, local, PROMPT_PATH, BASE_PROMPT;
+var 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");
-    BASE_PROMPT = fs10.readFileSync(PROMPT_PATH, "utf-8").trim();
+    init_assets();
+    BASE_PROMPT = readAsset("subagents/browserAutomation", "prompt.md");
   }
 });
 
@@ -2457,7 +2657,7 @@ var init_browserAutomation = __esm({
     browserAutomationTool = {
       definition: {
         name: "runAutomatedBrowserTest",
-        description: "Run an automated browser test against the live preview. Describe what to test \u2014 the agent figures out how. Use after writing or modifying frontend code, to reproduce user-reported issues, or to test end-to-end flows.",
+        description: "Run an automated browser test against the live preview. Describe what to test \u2014 the agent figures out how. Use after meaningful changes frontend code, to reproduce user-reported issues, or to test end-to-end flows.",
         inputSchema: {
           type: "object",
           properties: {
@@ -2490,10 +2690,10 @@ var init_browserAutomation = __esm({
           task: input.task,
           tools: BROWSER_TOOLS,
           externalTools: BROWSER_EXTERNAL_TOOLS,
-          executeTool: async (name) => {
-            if (name === "screenshot") {
+          executeTool: async (name, _input, _toolCallId, onLog) => {
+            if (name === "screenshotFullPage") {
               try {
-                return await captureAndAnalyzeScreenshot();
+                return await captureAndAnalyzeScreenshot({ onLog });
               } catch (err) {
                 return `Error taking screenshot: ${err.message}`;
               }
@@ -2523,7 +2723,7 @@ var init_browserAutomation = __esm({
               try {
                 const parsed = JSON.parse(result2);
                 const screenshotSteps = (parsed.steps || []).filter(
-                  (s) => s.command === "screenshot" && s.result?.url
+                  (s) => s.command === "screenshotViewport" && s.result?.url
                 );
                 if (screenshotSteps.length > 0) {
                   const batchInput = screenshotSteps.map((s) => ({
@@ -2541,7 +2741,7 @@ var init_browserAutomation = __esm({
                     const analyses = JSON.parse(batchResult);
                     let ai = 0;
                     for (const step of parsed.steps) {
-                      if (step.command === "screenshot" && step.result?.url && ai < analyses.length) {
+                      if (step.command === "screenshotViewport" && step.result?.url && ai < analyses.length) {
                         step.result.analysis = analyses[ai]?.output?.analysis || analyses[ai]?.output || "";
                         ai++;
                       }
@@ -2557,7 +2757,8 @@ var init_browserAutomation = __esm({
               }
             }
             return result2;
-          }
+          },
+          toolRegistry: context.toolRegistry
         });
         context.subAgentMessages?.set(context.toolCallId, result.messages);
         return result.text;
@@ -2566,262 +2767,471 @@ var init_browserAutomation = __esm({
   }
 });
 
-// src/subagents/designExpert/tools.ts
-import fs11 from "fs";
-import path5 from "path";
-function resolvePath(filename) {
-  const local4 = path5.join(base2, filename);
-  return fs11.existsSync(local4) ? local4 : path5.join(base2, "subagents", "designExpert", filename);
+// src/subagents/designExpert/tools/searchGoogle.ts
+var searchGoogle_exports = {};
+__export(searchGoogle_exports, {
+  definition: () => definition,
+  execute: () => execute
+});
+async function execute(input, onLog) {
+  return runCli(
+    `mindstudio search-google --query ${JSON.stringify(input.query)} --export-type json --output-key results --no-meta`,
+    { onLog }
+  );
 }
-async function executeDesignExpertTool(name, input, context, toolCallId) {
-  switch (name) {
-    case "screenshot": {
-      try {
-        return await captureAndAnalyzeScreenshot({
-          prompt: input.prompt,
-          fullPage: input.fullPage
-        });
-      } catch (err) {
-        return `Error taking screenshot: ${err.message}`;
+var definition;
+var init_searchGoogle2 = __esm({
+  "src/subagents/designExpert/tools/searchGoogle.ts"() {
+    "use strict";
+    init_runCli();
+    definition = {
+      name: "searchGoogle",
+      description: 'Search Google for web results. Reserch modern design trends in industries or verticals, "best [domain] apps 2026", ui patterns, or find something specific if the the user has an explicit reference. Prioritize authoritative sources like Figma and other design leaders, avoid random blog spam. Pick one or more URLs from the results and then use `fetchUrl` to get their text content.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query."
+          }
+        },
+        required: ["query"]
       }
-    }
-    case "searchGoogle":
-      return runCli(
-        `mindstudio search-google --query ${JSON.stringify(input.query)} --export-type json --output-key results --no-meta`
-      );
-    case "fetchUrl": {
-      const pageOptions = { onlyMainContent: true };
-      if (input.screenshot) {
-        pageOptions.screenshot = true;
+    };
+  }
+});
+
+// src/subagents/designExpert/tools/fetchUrl.ts
+var fetchUrl_exports = {};
+__export(fetchUrl_exports, {
+  definition: () => definition2,
+  execute: () => execute2
+});
+async function execute2(input, onLog) {
+  const pageOptions = { onlyMainContent: true };
+  if (input.screenshot) {
+    pageOptions.screenshot = true;
+  }
+  return runCli(
+    `mindstudio scrape-url --url ${JSON.stringify(input.url)} --page-options ${JSON.stringify(JSON.stringify(pageOptions))} --no-meta`,
+    { onLog }
+  );
+}
+var definition2;
+var init_fetchUrl2 = __esm({
+  "src/subagents/designExpert/tools/fetchUrl.ts"() {
+    "use strict";
+    init_runCli();
+    definition2 = {
+      name: "fetchUrl",
+      description: "Fetch the content of a web page as markdown. Use when reading sites from search results or specific things the user wants to incorporate.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          url: {
+            type: "string",
+            description: "The URL to fetch."
+          }
+        },
+        required: ["url"]
       }
-      return runCli(
-        `mindstudio scrape-url --url ${JSON.stringify(input.url)} --page-options ${JSON.stringify(JSON.stringify(pageOptions))} --no-meta`
-      );
+    };
+  }
+});
+
+// src/subagents/designExpert/tools/analyzeDesign.ts
+var analyzeDesign_exports = {};
+__export(analyzeDesign_exports, {
+  definition: () => definition3,
+  execute: () => execute3
+});
+async function execute3(input, onLog) {
+  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`,
+      { timeout: 12e4, onLog }
+    );
+    if (ssUrl.startsWith("Error")) {
+      return `Could not screenshot ${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`,
-          { timeout: 12e4 }
-        );
-        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(imageUrl)} --output-key analysis --no-meta`,
-        { timeout: 2e5 }
-      );
-      return isImageUrl ? analysis : `Screenshot: ${imageUrl}
+    imageUrl = ssUrl;
+  }
+  const analysis = await runCli(
+    `mindstudio analyze-image --prompt ${JSON.stringify(analysisPrompt)} --image-url ${JSON.stringify(imageUrl)} --output-key analysis --no-meta`,
+    { timeout: 2e5, onLog }
+  );
+  return isImageUrl ? analysis : `Screenshot: ${imageUrl}
 
 ${analysis}`;
-    }
-    case "generateImages": {
-      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],
-          imageModelOverride: {
-            model: "seedream-4.5",
-            config: { width, height }
+}
+var DESIGN_REFERENCE_PROMPT, definition3;
+var init_analyzeDesign = __esm({
+  "src/subagents/designExpert/tools/analyzeDesign.ts"() {
+    "use strict";
+    init_runCli();
+    DESIGN_REFERENCE_PROMPT = `
+You are analyzing a screenshot of a real website or app for a designer's personal technique/inspiration reference notes.
+
+Analyze the image and think about what makes the site or app special and unique.  What is it doing that is unique, different, original, and creative? What makes it special? What isn't working? What doesn't look or feel good?
+
+Then, provide the following analysis:
+
+## Context
+What is this page, and what does it look like? Very briefly note the industry/vertical and purpose, then describe the composition with enough context to frame the analysis that follows \u2014 what's on the page, where things are positioned, what does the viewport look and feel like. Give enough detail that someone who can't see the image could understand the spatial references in the techniques section. Do not mention specific brand names. Keep it concise.
+
+## Colors
+List the palette as hex values with short labels. Just the swatches \u2014 no "strategy" paragraph.
+
+## Typography
+Brief description of the types used on the page. If you can identify the actual typeface name, provide it, otherwise provide a concrete description (e.g., "ultra-condensed grotesque, ~900 weight, tracked tight at maybe -0.03em, all-caps"). Include size relationships if notable (e.g., "hero text is viewport-width, body is 14px").
+
+## Techniques
+Identify the specific design moves that make this page interesting and unique, described in terms of how a designer with a technical background would write them down as notes in their notebook for inspiration. Focus only on the non-obvious, hard-to-think-of techniques \u2014 the things that make this page gallery-worthy. Skip basics like "high contrast CTA" or "generous whitespace" that any competent designer already knows.
+
+Respond only with your analysis as Markdown and absolutely no other text. Do not use emojis - use unicode if you need symbols.
+`;
+    definition3 = {
+      name: "analyzeDesign",
+      description: "Analyze the visual design of a website or image 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 design question instead.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          url: {
+            type: "string",
+            description: "URL to analyze. Can be an image URL or a website URL (will be screenshotted)."
+          },
+          prompt: {
+            type: "string",
+            description: "Optional custom analysis prompt. If omitted, performs the standard design reference analysis."
           }
-        });
-        const url = await runCli(
-          `mindstudio generate-image '${step}' --output-key imageUrl --no-meta`,
-          { jsonLogs: true, timeout: 2e5 }
-        );
-        imageUrls = [url];
-      } else {
-        const steps = prompts.map((prompt) => ({
-          stepType: "generateImage",
-          step: {
-            prompt,
-            imageModelOverride: {
-              model: "seedream-4.5",
-              config: { width, height }
-            }
+        },
+        required: ["url"]
+      }
+    };
+  }
+});
+
+// src/subagents/designExpert/tools/analyzeImage.ts
+var analyzeImage_exports = {};
+__export(analyzeImage_exports, {
+  definition: () => definition4,
+  execute: () => execute4
+});
+async function execute4(input, onLog) {
+  const imageUrl = input.imageUrl;
+  const prompt = input.prompt || DEFAULT_PROMPT;
+  const analysis = await runCli(
+    `mindstudio analyze-image --prompt ${JSON.stringify(prompt)} --image-url ${JSON.stringify(imageUrl)} --output-key analysis --no-meta`,
+    { timeout: 2e5, onLog }
+  );
+  return JSON.stringify({ url: imageUrl, analysis });
+}
+var DEFAULT_PROMPT, definition4;
+var init_analyzeImage = __esm({
+  "src/subagents/designExpert/tools/analyzeImage.ts"() {
+    "use strict";
+    init_runCli();
+    DEFAULT_PROMPT = "Describe everything visible in this image \u2014 every element, its position, its size relative to the frame, its colors, its content. Be comprhensive, thorough and spatial. After the inventory, note anything that looks visually broken (overlapping elements, clipped text, misaligned components). Respond only with your analysis as Markdown and absolutely no other text. Do not use emojis - use unicode if you need symbols.";
+    definition4 = {
+      name: "analyzeImage",
+      description: "Analyze an image by URL. Returns a detailed description of everything visible. Provide a custom prompt to ask a specific question instead of the default full description.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          imageUrl: {
+            type: "string",
+            description: "The image URL to analyze."
+          },
+          prompt: {
+            type: "string",
+            description: "Optional custom analysis prompt. If omitted, describes everything visible in the image."
           }
-        }));
-        const batchResult = await runCli(
-          `mindstudio batch '${JSON.stringify(steps)}' --no-meta`,
-          { jsonLogs: true, timeout: 2e5 }
-        );
-        try {
-          const parsed = JSON.parse(batchResult);
-          imageUrls = parsed.results.map(
-            (r) => r.output?.imageUrl ?? `Error: ${r.error}`
-          );
-        } catch {
-          return batchResult;
-        }
+        },
+        required: ["imageUrl"]
       }
-      const images = await Promise.all(
-        imageUrls.map(async (url, i) => {
-          if (url.startsWith("Error")) {
-            return { prompt: prompts[i], error: url };
+    };
+  }
+});
+
+// src/subagents/designExpert/tools/screenshot.ts
+var screenshot_exports = {};
+__export(screenshot_exports, {
+  definition: () => definition5,
+  execute: () => execute5
+});
+async function execute5(input, onLog) {
+  try {
+    return await captureAndAnalyzeScreenshot({
+      prompt: input.prompt,
+      onLog
+    });
+  } catch (err) {
+    return `Error taking screenshot: ${err.message}`;
+  }
+}
+var definition5;
+var init_screenshot3 = __esm({
+  "src/subagents/designExpert/tools/screenshot.ts"() {
+    "use strict";
+    init_screenshot();
+    definition5 = {
+      name: "screenshot",
+      description: "Capture a full-height screenshot of the current app preview. Returns a CDN URL along with visual analysis. Use to review the current state of the UI being built. Remember, the screenshot analysis is not overly precise - for example, it cannot reliably identify specific fonts by name \u2014 it can only describe what letterforms look like.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          prompt: {
+            type: "string",
+            description: "Optional specific question about the screenshot."
           }
-          const analysis = await runCli(
-            `mindstudio analyze-image --prompt ${JSON.stringify(ANALYZE_PROMPT)} --image-url ${JSON.stringify(url)} --output-key analysis --no-meta`,
-            { timeout: 2e5 }
-          );
-          return { url, prompt: prompts[i], analysis, width, height };
-        })
-      );
-      return `%%JSON%%${JSON.stringify({ images })}`;
-    }
-    case "runBrowserTest": {
-      if (!context) {
-        return "Error: browser testing requires execution context (only available in headless mode)";
+        }
       }
-      return browserAutomationTool.execute(
-        { task: input.task },
-        {
-          ...context,
-          toolCallId: toolCallId || context.toolCallId
+    };
+  }
+});
+
+// src/subagents/designExpert/tools/_seedream.ts
+async function seedreamGenerate(opts) {
+  const { prompts, sourceImages, transparentBackground, onLog } = opts;
+  const width = opts.width || 2048;
+  const height = opts.height || 2048;
+  const config = { width, height };
+  if (sourceImages?.length) {
+    config.images = sourceImages;
+  }
+  let imageUrls;
+  if (prompts.length === 1) {
+    const step = JSON.stringify({
+      prompt: prompts[0],
+      imageModelOverride: {
+        model: "seedream-4.5",
+        config
+      }
+    });
+    const url = await runCli(
+      `mindstudio generate-image ${JSON.stringify(step)} --output-key imageUrl --no-meta`,
+      { jsonLogs: true, timeout: 2e5, onLog }
+    );
+    imageUrls = [url];
+  } else {
+    const steps = prompts.map((prompt) => ({
+      stepType: "generateImage",
+      step: {
+        prompt,
+        imageModelOverride: {
+          model: "seedream-4.5",
+          config
         }
+      }
+    }));
+    const batchResult = await runCli(
+      `mindstudio batch ${JSON.stringify(JSON.stringify(steps))} --no-meta`,
+      { jsonLogs: true, timeout: 2e5, onLog }
+    );
+    try {
+      const parsed = JSON.parse(batchResult);
+      imageUrls = parsed.map(
+        (r) => r.output?.imageUrl ?? `Error: ${r.error}`
       );
+    } catch {
+      return batchResult;
     }
-    default:
-      return `Error: unknown tool "${name}"`;
   }
+  if (transparentBackground) {
+    imageUrls = await Promise.all(
+      imageUrls.map(async (url) => {
+        if (url.startsWith("Error")) {
+          return url;
+        }
+        const result = await runCli(
+          `mindstudio remove-background-from-image --image-url ${JSON.stringify(url)} --output-key imageUrl --no-meta`,
+          { timeout: 2e5, onLog }
+        );
+        return result.startsWith("Error") ? url : result;
+      })
+    );
+  }
+  const images = await Promise.all(
+    imageUrls.map(async (url, i) => {
+      if (url.startsWith("Error")) {
+        return { prompt: prompts[i], error: url };
+      }
+      const analysis = await runCli(
+        `mindstudio analyze-image --prompt ${JSON.stringify(ANALYZE_PROMPT)} --image-url ${JSON.stringify(url)} --output-key analysis --no-meta`,
+        { timeout: 2e5, onLog }
+      );
+      return { url, prompt: prompts[i], analysis, width, height };
+    })
+  );
+  return JSON.stringify({ images });
 }
-var base2, DESIGN_REFERENCE_PROMPT, DESIGN_EXPERT_TOOLS;
-var init_tools2 = __esm({
-  "src/subagents/designExpert/tools.ts"() {
+var ANALYZE_PROMPT;
+var init_seedream = __esm({
+  "src/subagents/designExpert/tools/_seedream.ts"() {
     "use strict";
     init_runCli();
-    init_screenshot();
-    init_browserAutomation();
-    base2 = import.meta.dirname ?? path5.dirname(new URL(import.meta.url).pathname);
-    DESIGN_REFERENCE_PROMPT = fs11.readFileSync(resolvePath("prompts/tool-prompts/design-analysis.md"), "utf-8").trim();
-    DESIGN_EXPERT_TOOLS = [
-      {
-        name: "searchGoogle",
-        description: 'Search Google for web results. Reserch modern design trends in industries or verticals, "best [domain] apps 2026", ui patterns, etc. Prioritize authoritative sources like Figma and other design leaders, avoid random blog spam. Pick one or more URLs from the results and then use `fetchUrl` to get their text content.',
-        inputSchema: {
-          type: "object",
-          properties: {
-            query: {
-              type: "string",
-              description: "The search query."
-            }
-          },
-          required: ["query"]
-        }
-      },
-      {
-        name: "fetchUrl",
-        description: "Fetch the content of a web page as markdown. Optionally capture a screenshot to see the visual design. Use when reading sites from search results or specific things the user wants to incorporate.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            url: {
-              type: "string",
-              description: "The URL to fetch."
+    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. Respond only with your analysis as Markdown and absolutely no other text. Do not use emojis - use unicode if you need symbols.";
+  }
+});
+
+// src/subagents/designExpert/tools/generateImages.ts
+var generateImages_exports = {};
+__export(generateImages_exports, {
+  definition: () => definition6,
+  execute: () => execute6
+});
+async function execute6(input, onLog) {
+  return seedreamGenerate({
+    prompts: input.prompts,
+    width: input.width,
+    height: input.height,
+    transparentBackground: input.transparentBackground,
+    onLog
+  });
+}
+var definition6;
+var init_generateImages = __esm({
+  "src/subagents/designExpert/tools/generateImages.ts"() {
+    "use strict";
+    init_seedream();
+    definition6 = {
+      name: "generateImages",
+      description: "Generate images using AI. Returns CDN URLs with a quality analysis for each image. Produces high-quality results for everything from 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: {
+          prompts: {
+            type: "array",
+            items: {
+              type: "string"
             },
-            screenshot: {
-              type: "boolean",
-              description: "Capture a screenshot of the page. Use when you need to see the visual design, not just the text."
-            }
+            description: "One or more image generation prompts. Be detailed: describe style, mood, composition, colors. Multiple prompts run in parallel."
           },
-          required: ["url"]
-        }
-      },
-      {
-        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: {
-            url: {
-              type: "string",
-              description: "URL to analyze. Can be an image URL or a website URL (will be screenshotted)."
-            },
-            prompt: {
-              type: "string",
-              description: "Optional custom analysis prompt. If omitted, performs the standard design reference analysis."
-            }
+          width: {
+            type: "number",
+            description: "Image width in pixels. Default 2048. Range: 2048-4096."
           },
-          required: ["url"]
-        }
-      },
-      {
-        name: "screenshot",
-        description: "Capture a screenshot of the app preview. Returns a CDN URL with visual analysis. Use to review the current state of the UI being built. By default captures the viewport. Set fullPage to capture the entire scrollable page.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            prompt: {
-              type: "string",
-              description: "Optional specific question about the screenshot."
-            },
-            fullPage: {
-              type: "boolean",
-              description: "Capture the full scrollable page instead of just the viewport. Use when you need to see below-the-fold content."
-            }
-          }
-        }
-      },
-      {
-        name: "runBrowserTest",
-        description: "Run an automated browser test against the live app preview. Use to verify implementation details via getComputedStyle: font-family names, exact colors, spacing, borders, shadows, font sizes, transforms. Only use this to evaluate computed CSS properties that can't be deduced from sceenshots.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            task: {
-              type: "string",
-              description: 'What to verify, in natural language. Focus on measurable properties: "Check the hero cards have border-radius: 24px and box-shadow" or "Verify the background color of the CTA section is #C4FF0D".'
-            }
+          height: {
+            type: "number",
+            description: "Image height in pixels. Default 2048. Range: 2048-4096."
           },
-          required: ["task"]
-        }
-      },
-      {
-        name: "generateImages",
-        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: {
-            prompts: {
-              type: "array",
-              items: {
-                type: "string"
-              },
-              description: "One or more image generation prompts. Be detailed: describe style, mood, composition, colors. Multiple prompts run in parallel."
+          transparentBackground: {
+            type: "boolean",
+            description: "Remove the background from generated images, producing transparent PNGs. Useful for icons, logos, product shots, and assets that need to be composited onto other backgrounds."
+          }
+        },
+        required: ["prompts"]
+      }
+    };
+  }
+});
+
+// src/subagents/designExpert/tools/editImages.ts
+var editImages_exports = {};
+__export(editImages_exports, {
+  definition: () => definition7,
+  execute: () => execute7
+});
+async function execute7(input, onLog) {
+  return seedreamGenerate({
+    prompts: input.prompts,
+    sourceImages: input.sourceImages,
+    width: input.width,
+    height: input.height,
+    transparentBackground: input.transparentBackground,
+    onLog
+  });
+}
+var definition7;
+var init_editImages = __esm({
+  "src/subagents/designExpert/tools/editImages.ts"() {
+    "use strict";
+    init_seedream();
+    definition7 = {
+      name: "editImages",
+      description: "Edit or transform existing images using AI. Provide one or more source image URLs as reference and a prompt describing the desired edit. Use for compositing, style transfer, subject transformation, blending multiple references, or incorporating one or more ferences into something new. Returns CDN URLs with analysis.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          prompts: {
+            type: "array",
+            items: {
+              type: "string"
             },
-            width: {
-              type: "number",
-              description: "Image width in pixels. Default 2048. Range: 2048-4096."
+            description: "One or more edit prompts describing how to transform the source images. Multiple prompts run in parallel, each using the same source images."
+          },
+          sourceImages: {
+            type: "array",
+            items: {
+              type: "string"
             },
-            height: {
-              type: "number",
-              description: "Image height in pixels. Default 2048. Range: 2048-4096."
-            }
+            description: "One or more source/reference image URLs. These are used as the basis for the edit \u2014 the AI will use them as reference for style, subject, or composition."
           },
-          required: ["prompts"]
-        }
+          width: {
+            type: "number",
+            description: "Output width in pixels. Default 2048. Range: 2048-4096."
+          },
+          height: {
+            type: "number",
+            description: "Output height in pixels. Default 2048. Range: 2048-4096."
+          },
+          transparentBackground: {
+            type: "boolean",
+            description: "Remove the background from output images, producing transparent PNGs."
+          }
+        },
+        required: ["prompts", "sourceImages"]
       }
-    ];
+    };
+  }
+});
+
+// src/subagents/designExpert/tools/index.ts
+async function executeDesignExpertTool(name, input, context, toolCallId, onLog) {
+  const tool = tools[name];
+  if (!tool) {
+    return `Error: unknown tool "${name}"`;
+  }
+  return tool.execute(input, onLog);
+}
+var tools, DESIGN_EXPERT_TOOLS;
+var init_tools2 = __esm({
+  "src/subagents/designExpert/tools/index.ts"() {
+    "use strict";
+    init_searchGoogle2();
+    init_fetchUrl2();
+    init_analyzeDesign();
+    init_analyzeImage();
+    init_screenshot3();
+    init_generateImages();
+    init_editImages();
+    tools = {
+      searchGoogle: searchGoogle_exports,
+      fetchUrl: fetchUrl_exports,
+      analyzeDesign: analyzeDesign_exports,
+      analyzeImage: analyzeImage_exports,
+      screenshot: screenshot_exports,
+      generateImages: generateImages_exports,
+      editImages: editImages_exports
+    };
+    DESIGN_EXPERT_TOOLS = Object.values(tools).map(
+      (t) => t.definition
+    );
   }
 });
 
 // src/subagents/common/context.ts
 import fs12 from "fs";
-import path6 from "path";
+import path5 from "path";
 function walkMdFiles(dir, skip) {
   const files = [];
   try {
     for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
-      const full = path6.join(dir, entry.name);
+      const full = path5.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!skip?.has(entry.name)) {
           files.push(...walkMdFiles(full, skip));
@@ -2915,23 +3325,7 @@ var init_context = __esm({
   }
 });
 
-// src/subagents/designExpert/prompt.ts
-import fs13 from "fs";
-import path7 from "path";
-function resolvePath2(filename) {
-  const local4 = path7.join(base3, filename);
-  return fs13.existsSync(local4) ? local4 : path7.join(base3, "subagents", "designExpert", filename);
-}
-function readFile(filename) {
-  return fs13.readFileSync(resolvePath2(filename), "utf-8").trim();
-}
-function readJson(filename, fallback) {
-  try {
-    return JSON.parse(fs13.readFileSync(resolvePath2(filename), "utf-8"));
-  } catch {
-    return fallback;
-  }
-}
+// src/subagents/designExpert/data/getFontLibrarySample.ts
 function sample(arr, n) {
   if (arr.length <= n) {
     return [...arr];
@@ -2943,10 +3337,12 @@ function sample(arr, n) {
   }
   return copy.slice(0, n);
 }
-function getDesignExpertPrompt() {
-  const fonts = sample(fontData.fonts, 30);
-  const pairings = sample(fontData.pairings, 20);
-  const images = sample(inspirationImages, 15);
+function getFontLibrarySample() {
+  const fonts = sample(fontData.fonts, 60);
+  const pairings = sample(fontData.pairings, 30);
+  if (!fonts.length) {
+    return "";
+  }
   const fontList = fonts.map((f) => {
     let cssInfo = "";
     if (f.source === "fontshare") {
@@ -2962,60 +3358,102 @@ function getDesignExpertPrompt() {
   const pairingList = pairings.map(
     (p) => `- **${p.heading.font}** (${p.heading.weight}) heading + **${p.body.font}** (${p.body.weight}) body`
   ).join("\n");
-  const fontsSection = fonts.length ? `<fonts_to_consider>
-## Fonts to consider
+  return `
+## Font Library
 
-A random sample from Fontshare, Open Foundry, and Google Fonts. Use these as starting points for font selection.
-CSS URL pattern: ${fontData.cssUrlPattern}
+A random sample from a curated font library. Use these as starting points for font selection.
+
+### Fonts
 
 ${fontList}
 
-### Suggested pairings
+### Pairings
+
+${pairingList}`.trim();
+}
+var fontData;
+var init_getFontLibrarySample = __esm({
+  "src/subagents/designExpert/data/getFontLibrarySample.ts"() {
+    "use strict";
+    init_assets();
+    fontData = readJsonAsset(
+      { cssUrlPattern: "", fonts: [], pairings: [] },
+      "subagents/designExpert/data/sources/fonts.json"
+    );
+  }
+});
 
-${pairingList}
-</fonts_to_consider>` : "";
-  const imageList = images.map((img) => `- ${img.analysis}`).join("\n\n");
-  const inspirationSection = images.length ? `<design_inspiration>
-## Design inspiration
+// src/subagents/designExpert/data/getDesignReferencesSample.ts
+function sample2(arr, n) {
+  if (arr.length <= n) {
+    return [...arr];
+  }
+  const copy = [...arr];
+  for (let i = copy.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [copy[i], copy[j]] = [copy[j], copy[i]];
+  }
+  return copy.slice(0, n);
+}
+function getDesignReferencesSample() {
+  const images = sample2(inspirationImages, 30);
+  if (!images.length) {
+    return "";
+  }
+  const imageList = images.map((img, i) => `### Reference ${i + 1}
+${img.analysis}`).join("\n\n");
+  return `
+## Design References
 
 This is what the bar looks like. These are real sites that made it onto curated design galleries because they did something bold, intentional, and memorable. Use them as inspiration and let the takeaways guide your work. Your designs should feel like they belong in this company.
 
-${imageList}
-</design_inspiration>` : "";
+${imageList}`.trim();
+}
+var inspirationImages;
+var init_getDesignReferencesSample = __esm({
+  "src/subagents/designExpert/data/getDesignReferencesSample.ts"() {
+    "use strict";
+    init_assets();
+    inspirationImages = readJsonAsset(
+      { images: [] },
+      "subagents/designExpert/data/sources/inspiration.json"
+    ).images;
+  }
+});
+
+// src/subagents/designExpert/prompt.ts
+import fs13 from "fs";
+function getDesignExpertPrompt() {
   const specContext = loadSpecContext();
   let prompt = PROMPT_TEMPLATE.replace(
-    "{{fonts_to_consider}}",
-    fontsSection
-  ).replace("{{inspiration_images}}", inspirationSection);
+    "{{font_library}}",
+    getFontLibrarySample()
+  ).replace("{{design_references}}", getDesignReferencesSample());
   if (specContext) {
     prompt += `
 
 ${specContext}`;
+  }
+  try {
+    fs13.writeFileSync(`.design-prompt.md`, prompt);
+  } catch {
   }
   return prompt;
 }
-var base3, RUNTIME_PLACEHOLDERS, PROMPT_TEMPLATE, fontData, inspirationImages;
+var SUBAGENT, RUNTIME_PLACEHOLDERS, PROMPT_TEMPLATE;
 var init_prompt2 = __esm({
   "src/subagents/designExpert/prompt.ts"() {
     "use strict";
+    init_assets();
     init_context();
-    base3 = import.meta.dirname ?? path7.dirname(new URL(import.meta.url).pathname);
-    RUNTIME_PLACEHOLDERS = /* @__PURE__ */ new Set([
-      "fonts_to_consider",
-      "inspiration_images"
-    ]);
-    PROMPT_TEMPLATE = readFile("prompt.md").replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+    init_getFontLibrarySample();
+    init_getDesignReferencesSample();
+    SUBAGENT = "subagents/designExpert";
+    RUNTIME_PLACEHOLDERS = /* @__PURE__ */ new Set(["font_library", "design_references"]);
+    PROMPT_TEMPLATE = readAsset(SUBAGENT, "prompt.md").replace(/\{\{([^}]+)\}\}/g, (match, key) => {
       const k = key.trim();
-      return RUNTIME_PLACEHOLDERS.has(k) ? match : readFile(k);
+      return RUNTIME_PLACEHOLDERS.has(k) ? match : readAsset(SUBAGENT, k);
     }).replace(/\n{3,}/g, "\n\n");
-    fontData = readJson("data/fonts.json", {
-      cssUrlPattern: "",
-      fonts: [],
-      pairings: []
-    });
-    inspirationImages = readJson("data/inspiration.json", {
-      images: []
-    }).images;
   }
 });
 
@@ -3039,7 +3477,7 @@ Visual design expert. Describe the situation and what you need \u2014 the agent
           properties: {
             task: {
               type: "string",
-              description: "What you need, in natural language. Include context about the app when relevant."
+              description: "What you need, in natural language. Include context about the project when relevant."
             }
           },
           required: ["task"]
@@ -3054,14 +3492,15 @@ Visual design expert. Describe the situation and what you need \u2014 the agent
           task: input.task,
           tools: DESIGN_EXPERT_TOOLS,
           externalTools: /* @__PURE__ */ new Set(),
-          executeTool: (name, input2, toolCallId) => executeDesignExpertTool(name, input2, context, toolCallId),
+          executeTool: (name, input2, toolCallId, onLog) => executeDesignExpertTool(name, input2, context, toolCallId, onLog),
           apiConfig: context.apiConfig,
           model: context.model,
           subAgentId: "visualDesignExpert",
           signal: context.signal,
           parentToolId: context.toolCallId,
           onEvent: context.onEvent,
-          resolveExternalTool: context.resolveExternalTool
+          resolveExternalTool: context.resolveExternalTool,
+          toolRegistry: context.toolRegistry
         });
         context.subAgentMessages?.set(context.toolCallId, result.messages);
         return result.text;
@@ -3176,7 +3615,7 @@ var init_tools3 = __esm({
 
 // src/subagents/productVision/executor.ts
 import fs14 from "fs";
-import path8 from "path";
+import path6 from "path";
 function formatRequires(requires) {
   return requires.length === 0 ? "[]" : `[${requires.map((r) => `"${r}"`).join(", ")}]`;
 }
@@ -3191,7 +3630,7 @@ async function executeVisionTool(name, input) {
         requires,
         body
       } = input;
-      const filePath = path8.join(ROADMAP_DIR, `${slug}.md`);
+      const filePath = path6.join(ROADMAP_DIR, `${slug}.md`);
       try {
         fs14.mkdirSync(ROADMAP_DIR, { recursive: true });
         const oldContent = fs14.existsSync(filePath) ? fs14.readFileSync(filePath, "utf-8") : "";
@@ -3217,7 +3656,7 @@ ${unifiedDiff(filePath, oldContent, content)}`;
     }
     case "updateRoadmapItem": {
       const { slug } = input;
-      const filePath = path8.join(ROADMAP_DIR, `${slug}.md`);
+      const filePath = path6.join(ROADMAP_DIR, `${slug}.md`);
       try {
         if (!fs14.existsSync(filePath)) {
           return `Error: ${filePath} does not exist`;
@@ -3285,7 +3724,7 @@ ${unifiedDiff(filePath, oldContent, content)}`;
     }
     case "deleteRoadmapItem": {
       const { slug } = input;
-      const filePath = path8.join(ROADMAP_DIR, `${slug}.md`);
+      const filePath = path6.join(ROADMAP_DIR, `${slug}.md`);
       try {
         if (!fs14.existsSync(filePath)) {
           return `Error: ${filePath} does not exist`;
@@ -3313,8 +3752,6 @@ var init_executor = __esm({
 });
 
 // src/subagents/productVision/prompt.ts
-import fs15 from "fs";
-import path9 from "path";
 function getProductVisionPrompt() {
   const specContext = loadSpecContext();
   const roadmapContext = loadRoadmapContext();
@@ -3327,16 +3764,14 @@ function getProductVisionPrompt() {
   }
   return parts.join("\n\n");
 }
-var base4, local2, PROMPT_PATH2, BASE_PROMPT2;
+var BASE_PROMPT2;
 var init_prompt3 = __esm({
   "src/subagents/productVision/prompt.ts"() {
     "use strict";
+    init_assets();
     init_executor();
     init_context();
-    base4 = import.meta.dirname ?? path9.dirname(new URL(import.meta.url).pathname);
-    local2 = path9.join(base4, "prompt.md");
-    PROMPT_PATH2 = fs15.existsSync(local2) ? local2 : path9.join(base4, "subagents", "productVision", "prompt.md");
-    BASE_PROMPT2 = fs15.readFileSync(PROMPT_PATH2, "utf-8").trim();
+    BASE_PROMPT2 = readAsset("subagents/productVision", "prompt.md");
   }
 });
 
@@ -3380,7 +3815,8 @@ var init_productVision = __esm({
           signal: context.signal,
           parentToolId: context.toolCallId,
           onEvent: context.onEvent,
-          resolveExternalTool: context.resolveExternalTool
+          resolveExternalTool: context.resolveExternalTool,
+          toolRegistry: context.toolRegistry
         });
         context.subAgentMessages?.set(context.toolCallId, result.messages);
         return result.text;
@@ -3487,20 +3923,16 @@ var init_tools4 = __esm({
 });
 
 // src/subagents/codeSanityCheck/index.ts
-import fs16 from "fs";
-import path10 from "path";
-var base5, local3, PROMPT_PATH3, BASE_PROMPT3, codeSanityCheckTool;
+var BASE_PROMPT3, codeSanityCheckTool;
 var init_codeSanityCheck = __esm({
   "src/subagents/codeSanityCheck/index.ts"() {
     "use strict";
+    init_assets();
     init_runner();
     init_context();
     init_tools5();
     init_tools4();
-    base5 = import.meta.dirname ?? path10.dirname(new URL(import.meta.url).pathname);
-    local3 = path10.join(base5, "prompt.md");
-    PROMPT_PATH3 = fs16.existsSync(local3) ? local3 : path10.join(base5, "subagents", "codeSanityCheck", "prompt.md");
-    BASE_PROMPT3 = fs16.readFileSync(PROMPT_PATH3, "utf-8").trim();
+    BASE_PROMPT3 = readAsset("subagents/codeSanityCheck", "prompt.md");
     codeSanityCheckTool = {
       definition: {
         name: "codeSanityCheck",
@@ -3538,7 +3970,8 @@ var init_codeSanityCheck = __esm({
           signal: context.signal,
           parentToolId: context.toolCallId,
           onEvent: context.onEvent,
-          resolveExternalTool: context.resolveExternalTool
+          resolveExternalTool: context.resolveExternalTool,
+          toolRegistry: context.toolRegistry
         });
         context.subAgentMessages?.set(context.toolCallId, result.messages);
         return result.text;
@@ -3552,7 +3985,7 @@ function getSpecTools() {
   return [readSpecTool, writeSpecTool, editSpecTool, listSpecFilesTool];
 }
 function getCodeTools() {
-  const tools = [
+  const tools2 = [
     readFileTool,
     writeFileTool,
     editFileTool,
@@ -3567,9 +4000,9 @@ function getCodeTools() {
     browserAutomationTool
   ];
   if (isLspConfigured()) {
-    tools.push(lspDiagnosticsTool, restartProcessTool);
+    tools2.push(lspDiagnosticsTool, restartProcessTool);
   }
-  return tools;
+  return tools2;
 }
 function getCommonTools() {
   return [
@@ -3667,10 +4100,10 @@ var init_tools5 = __esm({
 });
 
 // src/session.ts
-import fs17 from "fs";
+import fs15 from "fs";
 function loadSession(state) {
   try {
-    const raw = fs17.readFileSync(SESSION_FILE, "utf-8");
+    const raw = fs15.readFileSync(SESSION_FILE, "utf-8");
     const data = JSON.parse(raw);
     if (Array.isArray(data.messages) && data.messages.length > 0) {
       state.messages = sanitizeMessages(data.messages);
@@ -3718,7 +4151,7 @@ function sanitizeMessages(messages) {
 }
 function saveSession(state) {
   try {
-    fs17.writeFileSync(
+    fs15.writeFileSync(
       SESSION_FILE,
       JSON.stringify({ messages: state.messages }, null, 2),
       "utf-8"
@@ -3729,7 +4162,7 @@ function saveSession(state) {
 function clearSession(state) {
   state.messages = [];
   try {
-    fs17.unlinkSync(SESSION_FILE);
+    fs15.unlinkSync(SESSION_FILE);
   } catch {
   }
 }
@@ -3910,91 +4343,6 @@ var init_parsePartialJson = __esm({
   }
 });
 
-// src/statusWatcher.ts
-function startStatusWatcher(config) {
-  const { apiConfig, getContext, onStatus, interval = 3e3, signal } = config;
-  let lastLabel = "";
-  let inflight = false;
-  let stopped = false;
-  const url = `${apiConfig.baseUrl}/_internal/v2/agent/remy/generate-status`;
-  async function tick() {
-    if (stopped || signal?.aborted || inflight) {
-      return;
-    }
-    inflight = true;
-    try {
-      const ctx = getContext();
-      if (!ctx.assistantText && !ctx.lastToolName) {
-        log.debug("Status watcher: no context, skipping");
-        return;
-      }
-      log.debug("Status watcher: requesting label", {
-        textLength: ctx.assistantText.length,
-        lastToolName: ctx.lastToolName
-      });
-      const res = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiConfig.apiKey}`
-        },
-        body: JSON.stringify({
-          assistantText: ctx.assistantText.slice(-500),
-          lastToolName: ctx.lastToolName,
-          lastToolResult: ctx.lastToolResult?.slice(-200),
-          onboardingState: ctx.onboardingState,
-          userMessage: ctx.userMessage?.slice(-200)
-        }),
-        signal
-      });
-      if (!res.ok) {
-        log.debug("Status watcher: endpoint returned non-ok", {
-          status: res.status
-        });
-        return;
-      }
-      const data = await res.json();
-      if (!data.label) {
-        log.debug("Status watcher: no label in response");
-        return;
-      }
-      if (data.label === lastLabel) {
-        log.debug("Status watcher: duplicate label, skipping", {
-          label: data.label
-        });
-        return;
-      }
-      lastLabel = data.label;
-      if (stopped) {
-        return;
-      }
-      log.debug("Status watcher: emitting", { label: data.label });
-      onStatus(data.label);
-    } catch (err) {
-      log.debug("Status watcher: error", { error: err?.message ?? "unknown" });
-    } finally {
-      inflight = false;
-    }
-  }
-  const timer = setInterval(tick, interval);
-  tick().catch(() => {
-  });
-  log.debug("Status watcher started", { interval });
-  return {
-    stop() {
-      stopped = true;
-      clearInterval(timer);
-      log.debug("Status watcher stopped");
-    }
-  };
-}
-var init_statusWatcher = __esm({
-  "src/statusWatcher.ts"() {
-    "use strict";
-    init_logger();
-  }
-});
-
 // src/errors.ts
 function friendlyError(raw) {
   for (const [pattern, message] of patterns) {
@@ -4051,13 +4399,14 @@ async function runTurn(params) {
     signal,
     onEvent,
     resolveExternalTool,
-    hidden
+    hidden,
+    toolRegistry
   } = params;
-  const tools = getToolDefinitions(onboardingState);
+  const tools2 = getToolDefinitions(onboardingState);
   log.info("Turn started", {
     messageLength: userMessage.length,
-    toolCount: tools.length,
-    tools: tools.map((t) => t.name),
+    toolCount: tools2.length,
+    tools: tools2.map((t) => t.name),
     ...attachments && attachments.length > 0 && {
       attachmentCount: attachments.length,
       attachmentUrls: attachments.map((a) => a.url)
@@ -4104,6 +4453,20 @@ async function runTurn(params) {
     let thinkingStartedAt = 0;
     const toolInputAccumulators = /* @__PURE__ */ new Map();
     let stopReason = "end_turn";
+    let subAgentText = "";
+    let currentToolNames = "";
+    const statusWatcher = startStatusWatcher({
+      apiConfig,
+      getContext: () => ({
+        assistantText: subAgentText || getTextContent(contentBlocks).slice(-500),
+        lastToolName: currentToolNames || getToolCalls(contentBlocks).filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).at(-1)?.name || lastCompletedTools || void 0,
+        lastToolResult: lastCompletedResult || void 0,
+        onboardingState,
+        userMessage
+      }),
+      onStatus: (label) => onEvent({ type: "status", message: label }),
+      signal
+    });
     async function handlePartialInput(acc, id, name, partial) {
       const tool = getToolByName(name);
       if (!tool?.streaming) {
@@ -4167,18 +4530,6 @@ async function runTurn(params) {
         onEvent({ type: "tool_input_delta", id, name, result: content });
       }
     }
-    const statusWatcher = startStatusWatcher({
-      apiConfig,
-      getContext: () => ({
-        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,
-        onboardingState,
-        userMessage
-      }),
-      onStatus: (label) => onEvent({ type: "status", message: label }),
-      signal
-    });
     try {
       for await (const event of streamChatWithRetry(
         {
@@ -4186,7 +4537,7 @@ async function runTurn(params) {
           model,
           system,
           messages: cleanMessagesForApi(state.messages),
-          tools,
+          tools: tools2,
           signal
         },
         {
@@ -4299,10 +4650,9 @@ async function runTurn(params) {
       } else {
         throw err;
       }
-    } finally {
-      statusWatcher.stop();
     }
     if (signal?.aborted) {
+      statusWatcher.stop();
       if (contentBlocks.length > 0) {
         contentBlocks.push({
           type: "text",
@@ -4324,6 +4674,7 @@ async function runTurn(params) {
     });
     const toolCalls = getToolCalls(contentBlocks);
     if (stopReason !== "tool_use" || toolCalls.length === 0) {
+      statusWatcher.stop();
       saveSession(state);
       onEvent({ type: "turn_done" });
       return;
@@ -4332,8 +4683,7 @@ async function runTurn(params) {
       count: toolCalls.length,
       tools: toolCalls.map((tc) => tc.name)
     });
-    let subAgentText = "";
-    const origOnEvent = onEvent;
+    currentToolNames = toolCalls.filter((tc) => !STATUS_EXCLUDED_TOOLS.has(tc.name)).map((tc) => tc.name).join(", ");
     const wrappedOnEvent = (e) => {
       if ("parentToolId" in e && e.parentToolId) {
         if (e.type === "text") {
@@ -4342,80 +4692,103 @@ async function runTurn(params) {
           subAgentText = `Using ${e.name}`;
         }
       }
-      origOnEvent(e);
+      onEvent(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,
-        onboardingState,
-        userMessage
-      }),
-      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) {
-          return {
-            id: tc.id,
-            result: "Error: cancelled",
-            isError: true
-          };
+          return { id: tc.id, result: "Error: cancelled", isError: true };
         }
         const toolStart = Date.now();
-        try {
-          let result;
-          if (EXTERNAL_TOOLS.has(tc.name) && resolveExternalTool) {
-            saveSession(state);
-            log.info("Waiting for external tool result", {
-              name: tc.name,
-              id: tc.id
-            });
-            result = await resolveExternalTool(tc.id, tc.name, tc.input);
-          } else {
-            result = await executeTool(tc.name, tc.input, {
-              apiConfig,
-              model,
-              signal,
-              onEvent: wrappedOnEvent,
-              resolveExternalTool,
-              toolCallId: tc.id,
-              subAgentMessages
+        let settle;
+        const resultPromise = new Promise((res) => {
+          settle = (result, isError) => res({ id: tc.id, result, isError });
+        });
+        let toolAbort = new AbortController();
+        const cascadeAbort = () => toolAbort.abort();
+        signal?.addEventListener("abort", cascadeAbort, { once: true });
+        let settled = false;
+        const safeSettle = (result, isError) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          signal?.removeEventListener("abort", cascadeAbort);
+          settle(result, isError);
+        };
+        const run = async (input) => {
+          try {
+            let result;
+            if (EXTERNAL_TOOLS.has(tc.name) && resolveExternalTool) {
+              saveSession(state);
+              log.info("Waiting for external tool result", {
+                name: tc.name,
+                id: tc.id
+              });
+              result = await resolveExternalTool(tc.id, tc.name, input);
+            } else {
+              result = await executeTool(tc.name, input, {
+                apiConfig,
+                model,
+                signal: toolAbort.signal,
+                onEvent: wrappedOnEvent,
+                resolveExternalTool,
+                toolCallId: tc.id,
+                subAgentMessages,
+                toolRegistry,
+                onLog: (line) => wrappedOnEvent({
+                  type: "tool_input_delta",
+                  id: tc.id,
+                  name: tc.name,
+                  result: line
+                })
+              });
+            }
+            safeSettle(result, result.startsWith("Error"));
+          } catch (err) {
+            safeSettle(`Error: ${err.message}`, true);
+          }
+        };
+        const entry = {
+          id: tc.id,
+          name: tc.name,
+          input: tc.input,
+          abortController: toolAbort,
+          startedAt: toolStart,
+          settle: safeSettle,
+          rerun: (newInput) => {
+            settled = false;
+            toolAbort = new AbortController();
+            signal?.addEventListener("abort", () => toolAbort.abort(), {
+              once: true
             });
+            entry.abortController = toolAbort;
+            entry.input = newInput;
+            run(newInput);
           }
-          const isError = result.startsWith("Error");
-          log.info("Tool completed", {
-            name: tc.name,
-            elapsed: `${Date.now() - toolStart}ms`,
-            isError,
-            resultLength: result.length
-          });
-          onEvent({
-            type: "tool_done",
-            id: tc.id,
-            name: tc.name,
-            result,
-            isError
-          });
-          return { id: tc.id, result, isError };
-        } catch (err) {
-          const errorMsg = `Error: ${err.message}`;
-          onEvent({
-            type: "tool_done",
-            id: tc.id,
-            name: tc.name,
-            result: errorMsg,
-            isError: true
-          });
-          return { id: tc.id, result: errorMsg, isError: true };
-        }
+        };
+        toolRegistry?.register(entry);
+        run(tc.input);
+        const r = await resultPromise;
+        toolRegistry?.unregister(tc.id);
+        log.info("Tool completed", {
+          name: tc.name,
+          elapsed: `${Date.now() - toolStart}ms`,
+          isError: r.isError,
+          resultLength: r.result.length
+        });
+        onEvent({
+          type: "tool_done",
+          id: tc.id,
+          name: tc.name,
+          result: r.result,
+          isError: r.isError
+        });
+        return r;
       })
     );
-    toolStatusWatcher.stop();
+    statusWatcher.stop();
     for (const r of results) {
       const block = contentBlocks.find(
         (b) => b.type === "tool" && b.id === r.id
@@ -4423,6 +4796,7 @@ async function runTurn(params) {
       if (block?.type === "tool") {
         block.result = r.result;
         block.isError = r.isError;
+        block.completedAt = Date.now();
         const msgs = subAgentMessages.get(r.id);
         if (msgs) {
           block.subAgentMessages = msgs;
@@ -4475,12 +4849,12 @@ var init_agent = __esm({
 });
 
 // src/prompt/static/projectContext.ts
-import fs18 from "fs";
-import path11 from "path";
+import fs16 from "fs";
+import path7 from "path";
 function loadProjectInstructions() {
   for (const file of AGENT_INSTRUCTION_FILES) {
     try {
-      const content = fs18.readFileSync(file, "utf-8").trim();
+      const content = fs16.readFileSync(file, "utf-8").trim();
       if (content) {
         return `
 ## Project Instructions (${file})
@@ -4493,7 +4867,7 @@ ${content}`;
 }
 function loadProjectManifest() {
   try {
-    const manifest = fs18.readFileSync("mindstudio.json", "utf-8");
+    const manifest = fs16.readFileSync("mindstudio.json", "utf-8");
     return `
 ## Project Manifest (mindstudio.json)
 \`\`\`json
@@ -4534,9 +4908,9 @@ ${entries.join("\n")}`;
 function walkMdFiles2(dir) {
   const results = [];
   try {
-    const entries = fs18.readdirSync(dir, { withFileTypes: true });
+    const entries = fs16.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path11.join(dir, entry.name);
+      const full = path7.join(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...walkMdFiles2(full));
       } else if (entry.name.endsWith(".md")) {
@@ -4549,7 +4923,7 @@ function walkMdFiles2(dir) {
 }
 function parseFrontmatter(filePath) {
   try {
-    const content = fs18.readFileSync(filePath, "utf-8");
+    const content = fs16.readFileSync(filePath, "utf-8");
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) {
       return { name: "", description: "", type: "" };
@@ -4565,7 +4939,7 @@ function parseFrontmatter(filePath) {
 }
 function loadProjectFileListing() {
   try {
-    const entries = fs18.readdirSync(".", { withFileTypes: true });
+    const entries = fs16.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;
@@ -4608,20 +4982,10 @@ var init_projectContext = __esm({
 });
 
 // src/prompt/index.ts
-import fs19 from "fs";
-import path12 from "path";
-function requireFile(filePath) {
-  const full = path12.join(PROMPT_DIR, filePath);
-  try {
-    return fs19.readFileSync(full, "utf-8").trim();
-  } catch {
-    throw new Error(`Required prompt file missing: ${full}`);
-  }
-}
 function resolveIncludes(template) {
   const result = template.replace(
     /\{\{([^}]+)\}\}/g,
-    (_, filePath) => requireFile(filePath.trim())
+    (_, filePath) => readAsset("prompt", filePath.trim())
   );
   return result.replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -4731,23 +5095,22 @@ ${viewContext?.activeFile ? `Active file: ${viewContext.activeFile}` : ""}
 `;
   return resolveIncludes(template);
 }
-var PROMPT_DIR;
 var init_prompt4 = __esm({
   "src/prompt/index.ts"() {
     "use strict";
+    init_assets();
     init_lsp();
     init_projectContext();
-    PROMPT_DIR = import.meta.dirname ?? path12.dirname(new URL(import.meta.url).pathname);
   }
 });
 
 // src/config.ts
-import fs20 from "fs";
-import path13 from "path";
+import fs17 from "fs";
+import path8 from "path";
 import os from "os";
 function loadConfigFile() {
   try {
-    const raw = fs20.readFileSync(CONFIG_PATH, "utf-8");
+    const raw = fs17.readFileSync(CONFIG_PATH, "utf-8");
     log.debug("Loaded config file", { path: CONFIG_PATH });
     return JSON.parse(raw);
   } catch (err) {
@@ -4783,7 +5146,7 @@ var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_logger();
-    CONFIG_PATH = path13.join(
+    CONFIG_PATH = path8.join(
       os.homedir(),
       ".mindstudio-local-tunnel",
       "config.json"
@@ -4792,16 +5155,92 @@ var init_config = __esm({
   }
 });
 
+// src/toolRegistry.ts
+var ToolRegistry;
+var init_toolRegistry = __esm({
+  "src/toolRegistry.ts"() {
+    "use strict";
+    ToolRegistry = class {
+      entries = /* @__PURE__ */ new Map();
+      onEvent;
+      register(entry) {
+        this.entries.set(entry.id, entry);
+      }
+      unregister(id) {
+        this.entries.delete(id);
+      }
+      get(id) {
+        return this.entries.get(id);
+      }
+      /**
+       * Stop a running tool.
+       *
+       * - graceful: abort and settle with [INTERRUPTED] + partial result
+       * - hard: abort and settle with a generic error
+       *
+       * Returns true if the tool was found and stopped.
+       */
+      stop(id, mode) {
+        const entry = this.entries.get(id);
+        if (!entry) {
+          return false;
+        }
+        entry.abortController.abort(mode);
+        if (mode === "graceful") {
+          const partial = entry.getPartialResult?.() ?? "";
+          const result = partial ? `[INTERRUPTED]
+
+${partial}` : "[INTERRUPTED] Tool execution was stopped.";
+          entry.settle(result, false);
+        } else {
+          entry.settle("Error: tool was cancelled", true);
+        }
+        this.onEvent?.({
+          type: "tool_stopped",
+          id: entry.id,
+          name: entry.name,
+          mode,
+          ...entry.parentToolId && { parentToolId: entry.parentToolId }
+        });
+        this.entries.delete(id);
+        return true;
+      }
+      /**
+       * Restart a running tool with the same or patched input.
+       * The original controllable promise stays pending and settles
+       * when the new execution finishes.
+       *
+       * Returns true if the tool was found and restarted.
+       */
+      restart(id, patchedInput) {
+        const entry = this.entries.get(id);
+        if (!entry) {
+          return false;
+        }
+        entry.abortController.abort("restart");
+        const newInput = patchedInput ? { ...entry.input, ...patchedInput } : entry.input;
+        this.onEvent?.({
+          type: "tool_restarted",
+          id: entry.id,
+          name: entry.name,
+          input: newInput,
+          ...entry.parentToolId && { parentToolId: entry.parentToolId }
+        });
+        entry.rerun(newInput);
+        return true;
+      }
+    };
+  }
+});
+
 // src/headless.ts
 var headless_exports = {};
 __export(headless_exports, {
   startHeadless: () => startHeadless
 });
 import { createInterface } from "readline";
-import fs21 from "fs";
-import path14 from "path";
 function loadActionPrompt(name) {
-  return fs21.readFileSync(path14.join(ACTIONS_DIR, `${name}.md`), "utf-8").trim();
+  return readAsset("prompt", "actions", `${name}.md`);
 }
 function emit(event, data, requestId) {
   const payload = { event, ...data };
@@ -4865,6 +5304,7 @@ async function startHeadless(opts = {}) {
   const EXTERNAL_TOOL_TIMEOUT_MS = 3e5;
   const pendingTools = /* @__PURE__ */ new Map();
   const earlyResults = /* @__PURE__ */ new Map();
+  const toolRegistry = new ToolRegistry();
   const USER_FACING_TOOLS = /* @__PURE__ */ new Set([
     "promptUser",
     "confirmDestructiveAction",
@@ -4969,14 +5409,46 @@ async function startHeadless(opts = {}) {
           rid
         );
         return;
+      case "tool_stopped":
+        emit(
+          "tool_stopped",
+          {
+            id: e.id,
+            name: e.name,
+            mode: e.mode,
+            ...e.parentToolId && { parentToolId: e.parentToolId }
+          },
+          rid
+        );
+        return;
+      case "tool_restarted":
+        emit(
+          "tool_restarted",
+          {
+            id: e.id,
+            name: e.name,
+            input: e.input,
+            ...e.parentToolId && { parentToolId: e.parentToolId }
+          },
+          rid
+        );
+        return;
       case "status":
-        emit("status", { message: e.message }, rid);
+        emit(
+          "status",
+          {
+            message: e.message,
+            ...e.parentToolId && { parentToolId: e.parentToolId }
+          },
+          rid
+        );
         return;
       case "error":
         emit("error", { error: e.error }, rid);
         return;
     }
   }
+  toolRegistry.onEvent = onEvent;
   async function handleMessage(parsed, requestId) {
     if (running) {
       emit(
@@ -5028,7 +5500,8 @@ async function startHeadless(opts = {}) {
         signal: currentAbort.signal,
         onEvent,
         resolveExternalTool,
-        hidden: isCommand
+        hidden: isCommand,
+        toolRegistry
       });
       if (!completedEmitted) {
         emit(
@@ -5082,6 +5555,36 @@ async function startHeadless(opts = {}) {
       emit("completed", { success: true }, requestId);
       return;
     }
+    if (action === "stop_tool") {
+      const id = parsed.id;
+      const mode = parsed.mode ?? "hard";
+      const found = toolRegistry.stop(id, mode);
+      if (found) {
+        emit("completed", { success: true }, requestId);
+      } else {
+        emit(
+          "completed",
+          { success: false, error: "Tool not found" },
+          requestId
+        );
+      }
+      return;
+    }
+    if (action === "restart_tool") {
+      const id = parsed.id;
+      const patchedInput = parsed.input;
+      const found = toolRegistry.restart(id, patchedInput);
+      if (found) {
+        emit("completed", { success: true }, requestId);
+      } else {
+        emit(
+          "completed",
+          { success: false, error: "Tool not found" },
+          requestId
+        );
+      }
+      return;
+    }
     if (action === "message") {
       await handleMessage(parsed, requestId);
       return;
@@ -5107,25 +5610,24 @@ async function startHeadless(opts = {}) {
   process.on("SIGINT", shutdown);
   emit("ready");
 }
-var BASE_DIR, ACTIONS_DIR;
 var init_headless = __esm({
   "src/headless.ts"() {
     "use strict";
+    init_assets();
     init_config();
     init_prompt4();
     init_lsp();
     init_agent();
     init_session();
-    BASE_DIR = import.meta.dirname ?? path14.dirname(new URL(import.meta.url).pathname);
-    ACTIONS_DIR = path14.join(BASE_DIR, "actions");
+    init_toolRegistry();
   }
 });
 
 // src/index.tsx
 import { render } from "ink";
 import os2 from "os";
-import fs22 from "fs";
-import path15 from "path";
+import fs18 from "fs";
+import path9 from "path";
 
 // src/tui/App.tsx
 import { useState as useState2, useCallback, useRef } from "react";
@@ -5442,8 +5944,8 @@ for (let i = 0; i < args.length; i++) {
 }
 function printDebugInfo(config) {
   const pkg = JSON.parse(
-    fs22.readFileSync(
-      path15.join(import.meta.dirname, "..", "package.json"),
+    fs18.readFileSync(
+      path9.join(import.meta.dirname, "..", "package.json"),
       "utf-8"
     )
   );