@mindstudio-ai/remy 0.1.34 → 0.1.36

package/dist/headless.js

@@ -1,15 +1,56 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/headless.ts
 import { createInterface } from "readline";
-import fs21 from "fs";
-import path14 from "path";
 
-// src/config.ts
-import fs2 from "fs";
+// src/assets.ts
+import fs from "fs";
 import path from "path";
+var ROOT = findRoot(
+  import.meta.dirname ?? path.dirname(new URL(import.meta.url).pathname)
+);
+function findRoot(start) {
+  let dir = start;
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return start;
+}
+var ASSETS_BASE = fs.existsSync(path.join(ROOT, "dist", "prompt")) ? path.join(ROOT, "dist") : path.join(ROOT, "src");
+function assetPath(...segments) {
+  return path.join(ASSETS_BASE, ...segments);
+}
+function readAsset(...segments) {
+  const full = assetPath(...segments);
+  try {
+    return fs.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(fs.readFileSync(full, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+
+// src/config.ts
+import fs3 from "fs";
+import path2 from "path";
 import os from "os";
 
 // src/logger.ts
-import fs from "fs";
+import fs2 from "fs";
 var LEVELS = {
   error: 0,
   warn: 1,
@@ -62,7 +103,7 @@ var log = {
 };
 
 // src/config.ts
-var CONFIG_PATH = path.join(
+var CONFIG_PATH = path2.join(
   os.homedir(),
   ".mindstudio-local-tunnel",
   "config.json"
@@ -70,7 +111,7 @@ var CONFIG_PATH = path.join(
 var DEFAULT_BASE_URL = "https://api.mindstudio.ai";
 function loadConfigFile() {
   try {
-    const raw = fs2.readFileSync(CONFIG_PATH, "utf-8");
+    const raw = fs3.readFileSync(CONFIG_PATH, "utf-8");
     log.debug("Loaded config file", { path: CONFIG_PATH });
     return JSON.parse(raw);
   } catch (err) {
@@ -102,10 +143,6 @@ function resolveConfig(flags) {
   return { apiKey, baseUrl: baseUrl2 };
 }
 
-// src/prompt/index.ts
-import fs4 from "fs";
-import path3 from "path";
-
 // src/tools/_helpers/sidecar.ts
 var baseUrl = null;
 function setSidecarBaseUrl(url) {
@@ -150,8 +187,8 @@ async function lspRequest(endpoint, body) {
 }
 
 // src/prompt/static/projectContext.ts
-import fs3 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path3 from "path";
 var AGENT_INSTRUCTION_FILES = [
   "CLAUDE.md",
   "claude.md",
@@ -171,7 +208,7 @@ var AGENT_INSTRUCTION_FILES = [
 function loadProjectInstructions() {
   for (const file of AGENT_INSTRUCTION_FILES) {
     try {
-      const content = fs3.readFileSync(file, "utf-8").trim();
+      const content = fs4.readFileSync(file, "utf-8").trim();
       if (content) {
         return `
 ## Project Instructions (${file})
@@ -184,7 +221,7 @@ ${content}`;
 }
 function loadProjectManifest() {
   try {
-    const manifest = fs3.readFileSync("mindstudio.json", "utf-8");
+    const manifest = fs4.readFileSync("mindstudio.json", "utf-8");
     return `
 ## Project Manifest (mindstudio.json)
 \`\`\`json
@@ -225,9 +262,9 @@ ${entries.join("\n")}`;
 function walkMdFiles(dir) {
   const results = [];
   try {
-    const entries = fs3.readdirSync(dir, { withFileTypes: true });
+    const entries = fs4.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path2.join(dir, entry.name);
+      const full = path3.join(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...walkMdFiles(full));
       } else if (entry.name.endsWith(".md")) {
@@ -240,7 +277,7 @@ function walkMdFiles(dir) {
 }
 function parseFrontmatter(filePath) {
   try {
-    const content = fs3.readFileSync(filePath, "utf-8");
+    const content = fs4.readFileSync(filePath, "utf-8");
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) {
       return { name: "", description: "", type: "" };
@@ -256,7 +293,7 @@ function parseFrontmatter(filePath) {
 }
 function loadProjectFileListing() {
   try {
-    const entries = fs3.readdirSync(".", { withFileTypes: true });
+    const entries = fs4.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;
@@ -277,19 +314,10 @@ ${listing}
 }
 
 // src/prompt/index.ts
-var PROMPT_DIR = import.meta.dirname ?? path3.dirname(new URL(import.meta.url).pathname);
-function requireFile(filePath) {
-  const full = path3.join(PROMPT_DIR, filePath);
-  try {
-    return fs4.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();
 }
@@ -1284,7 +1312,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 {
         }
@@ -1296,7 +1329,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);
@@ -1328,11 +1361,12 @@ var askMindStudioSdkTool = {
       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
     });
   }
 };
@@ -1357,7 +1391,7 @@ var fetchUrlTool = {
       required: ["url"]
     }
   },
-  async execute(input) {
+  async execute(input, context) {
     const url = input.url;
     const screenshot = input.screenshot;
     const pageOptions = { onlyMainContent: true };
@@ -1365,7 +1399,8 @@ var fetchUrlTool = {
       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 }
     );
   }
 };
@@ -1386,11 +1421,11 @@ var searchGoogleTool = {
       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 }
     );
   }
 };
@@ -1420,9 +1455,9 @@ var setProjectNameTool = {
 import fs9 from "fs/promises";
 var DEFAULT_MAX_LINES2 = 500;
 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;
     }
   }
@@ -2074,21 +2109,19 @@ var runMethodTool = {
 };
 
 // src/tools/_helpers/screenshot.ts
-var 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).";
+var 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.";
 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) {
@@ -2102,7 +2135,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 });
 }
@@ -2111,26 +2144,22 @@ async function captureAndAnalyzeScreenshot(promptOrOptions) {
 var 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}`;
@@ -2138,6 +2167,85 @@ var screenshotTool = {
   }
 };
 
+// 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");
+    }
+  };
+}
+
 // src/subagents/common/cleanMessages.ts
 function cleanMessagesForApi(messages) {
   return messages.map((msg) => {
@@ -2172,7 +2280,7 @@ async function runSubAgent(config) {
   const {
     system,
     task,
-    tools,
+    tools: tools2,
     externalTools,
     executeTool: executeTool2,
     apiConfig,
@@ -2181,19 +2289,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")}`;
@@ -2204,7 +2340,7 @@ Current date/time: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " "
         subAgentId,
         system: fullSystem,
         messages: cleanMessagesForApi(messages),
-        tools,
+        tools: tools2,
         signal
       })) {
         if (signal?.aborted) {
@@ -2269,7 +2405,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",
@@ -2279,6 +2416,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 };
     }
@@ -2287,40 +2425,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
@@ -2328,6 +2508,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",
@@ -2365,7 +2546,7 @@ var BROWSER_TOOLS = [
                   "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",
@@ -2421,8 +2602,8 @@ var BROWSER_TOOLS = [
     }
   },
   {
-    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: {}
@@ -2441,11 +2622,7 @@ var BROWSER_EXTERNAL_TOOLS = /* @__PURE__ */ new Set(["browserCommand"]);
 
 // src/subagents/browserAutomation/prompt.ts
 import fs13 from "fs";
-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 BASE_PROMPT = fs13.readFileSync(PROMPT_PATH, "utf-8").trim();
+var BASE_PROMPT = readAsset("subagents/browserAutomation", "prompt.md");
 function getBrowserAutomationPrompt() {
   try {
     const appSpec = fs13.readFileSync("src/app.md", "utf-8").trim();
@@ -2463,7 +2640,7 @@ ${appSpec}
 var 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: {
@@ -2496,10 +2673,10 @@ var browserAutomationTool = {
       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}`;
           }
@@ -2529,7 +2706,7 @@ var browserAutomationTool = {
           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) => ({
@@ -2547,7 +2724,7 @@ var browserAutomationTool = {
                 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++;
                   }
@@ -2563,264 +2740,415 @@ var browserAutomationTool = {
           }
         }
         return result2;
-      }
+      },
+      toolRegistry: context.toolRegistry
     });
     context.subAgentMessages?.set(context.toolCallId, result.messages);
     return result.text;
   }
 };
 
-// src/subagents/designExpert/tools.ts
-import fs14 from "fs";
-import path8 from "path";
-var base2 = import.meta.dirname ?? path8.dirname(new URL(import.meta.url).pathname);
-function resolvePath(filename) {
-  const local4 = path8.join(base2, filename);
-  return fs14.existsSync(local4) ? local4 : path8.join(base2, "subagents", "designExpert", filename);
+// src/subagents/designExpert/tools/searchGoogle.ts
+var searchGoogle_exports = {};
+__export(searchGoogle_exports, {
+  definition: () => definition,
+  execute: () => execute
+});
+var 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"]
+  }
+};
+async function execute(input, onLog) {
+  return runCli(
+    `mindstudio search-google --query ${JSON.stringify(input.query)} --export-type json --output-key results --no-meta`,
+    { onLog }
+  );
 }
-var DESIGN_REFERENCE_PROMPT = fs14.readFileSync(resolvePath("prompts/tool-prompts/design-analysis.md"), "utf-8").trim();
-var 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."
-        },
-        screenshot: {
-          type: "boolean",
-          description: "Capture a screenshot of the page. Use when you need to see the visual design, not just the text."
-        }
+
+// src/subagents/designExpert/tools/fetchUrl.ts
+var fetchUrl_exports = {};
+__export(fetchUrl_exports, {
+  definition: () => definition2,
+  execute: () => execute2
+});
+var 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"]
+  }
+};
+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 }
+  );
+}
+
+// src/subagents/designExpert/tools/analyzeDesign.ts
+var analyzeDesign_exports = {};
+__export(analyzeDesign_exports, {
+  definition: () => definition3,
+  execute: () => execute3
+});
+var 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.
+`;
+var 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)."
       },
-      required: ["url"]
+      prompt: {
+        type: "string",
+        description: "Optional custom analysis prompt. If omitted, performs the standard design reference analysis."
+      }
+    },
+    required: ["url"]
+  }
+};
+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}`;
     }
-  },
-  {
-    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."
-        }
+    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}`;
+}
+
+// src/subagents/designExpert/tools/analyzeImage.ts
+var analyzeImage_exports = {};
+__export(analyzeImage_exports, {
+  definition: () => definition4,
+  execute: () => execute4
+});
+var 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.";
+var 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."
       },
-      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."
-        }
+      prompt: {
+        type: "string",
+        description: "Optional custom analysis prompt. If omitted, describes everything visible in the image."
       }
-    }
-  },
-  {
-    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".'
-        }
-      },
-      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."
-        },
-        width: {
-          type: "number",
-          description: "Image width in pixels. Default 2048. Range: 2048-4096."
-        },
-        height: {
-          type: "number",
-          description: "Image height in pixels. Default 2048. Range: 2048-4096."
-        }
-      },
-      required: ["prompts"]
-    }
+    },
+    required: ["imageUrl"]
   }
-];
-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}`;
+};
+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 });
+}
+
+// src/subagents/designExpert/tools/screenshot.ts
+var screenshot_exports = {};
+__export(screenshot_exports, {
+  definition: () => definition5,
+  execute: () => execute5
+});
+var 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."
       }
     }
-    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;
+  }
+};
+async function execute5(input, onLog) {
+  try {
+    return await captureAndAnalyzeScreenshot({
+      prompt: input.prompt,
+      onLog
+    });
+  } catch (err) {
+    return `Error taking screenshot: ${err.message}`;
+  }
+}
+
+// src/subagents/designExpert/tools/generateImages.ts
+var generateImages_exports = {};
+__export(generateImages_exports, {
+  definition: () => definition6,
+  execute: () => execute6
+});
+
+// src/subagents/designExpert/tools/_seedream.ts
+var 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.";
+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
+        }
       }
-      return runCli(
-        `mindstudio scrape-url --url ${JSON.stringify(input.url)} --page-options ${JSON.stringify(JSON.stringify(pageOptions))} --no-meta`
+    }));
+    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;
     }
-    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}`;
+  }
+  if (transparentBackground) {
+    imageUrls = await Promise.all(
+      imageUrls.map(async (url) => {
+        if (url.startsWith("Error")) {
+          return url;
         }
-        imageUrl = ssUrl;
+        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(analysisPrompt)} --image-url ${JSON.stringify(imageUrl)} --output-key analysis --no-meta`,
-        { timeout: 2e5 }
+        `mindstudio analyze-image --prompt ${JSON.stringify(ANALYZE_PROMPT)} --image-url ${JSON.stringify(url)} --output-key analysis --no-meta`,
+        { timeout: 2e5, onLog }
       );
-      return isImageUrl ? analysis : `Screenshot: ${imageUrl}
+      return { url, prompt: prompts[i], analysis, width, height };
+    })
+  );
+  return JSON.stringify({ images });
+}
 
-${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 }
-          }
-        });
-        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 }
-            }
-          }
-        }));
-        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;
-        }
+// src/subagents/designExpert/tools/generateImages.ts
+var 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"
+        },
+        description: "One or more image generation prompts. Be detailed: describe style, mood, composition, colors. Multiple prompts run in parallel."
+      },
+      width: {
+        type: "number",
+        description: "Image width in pixels. Default 2048. Range: 2048-4096."
+      },
+      height: {
+        type: "number",
+        description: "Image height in pixels. Default 2048. Range: 2048-4096."
+      },
+      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."
       }
-      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 }
-          );
-          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)";
+    },
+    required: ["prompts"]
+  }
+};
+async function execute6(input, onLog) {
+  return seedreamGenerate({
+    prompts: input.prompts,
+    width: input.width,
+    height: input.height,
+    transparentBackground: input.transparentBackground,
+    onLog
+  });
+}
+
+// src/subagents/designExpert/tools/editImages.ts
+var editImages_exports = {};
+__export(editImages_exports, {
+  definition: () => definition7,
+  execute: () => execute7
+});
+var 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"
+        },
+        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"
+        },
+        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."
+      },
+      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."
       }
-      return browserAutomationTool.execute(
-        { task: input.task },
-        {
-          ...context,
-          toolCallId: toolCallId || context.toolCallId
-        }
-      );
-    }
-    default:
-      return `Error: unknown tool "${name}"`;
+    },
+    required: ["prompts", "sourceImages"]
   }
+};
+async function execute7(input, onLog) {
+  return seedreamGenerate({
+    prompts: input.prompts,
+    sourceImages: input.sourceImages,
+    width: input.width,
+    height: input.height,
+    transparentBackground: input.transparentBackground,
+    onLog
+  });
+}
+
+// src/subagents/designExpert/tools/index.ts
+var tools = {
+  searchGoogle: searchGoogle_exports,
+  fetchUrl: fetchUrl_exports,
+  analyzeDesign: analyzeDesign_exports,
+  analyzeImage: analyzeImage_exports,
+  screenshot: screenshot_exports,
+  generateImages: generateImages_exports,
+  editImages: editImages_exports
+};
+var DESIGN_EXPERT_TOOLS = Object.values(tools).map(
+  (t) => t.definition
+);
+async function executeDesignExpertTool(name, input, context, toolCallId, onLog) {
+  const tool = tools[name];
+  if (!tool) {
+    return `Error: unknown tool "${name}"`;
+  }
+  return tool.execute(input, onLog);
 }
 
 // src/subagents/designExpert/prompt.ts
-import fs16 from "fs";
-import path10 from "path";
+import fs15 from "fs";
 
 // src/subagents/common/context.ts
-import fs15 from "fs";
-import path9 from "path";
+import fs14 from "fs";
+import path7 from "path";
 function walkMdFiles2(dir, skip) {
   const files = [];
   try {
-    for (const entry of fs15.readdirSync(dir, { withFileTypes: true })) {
-      const full = path9.join(dir, entry.name);
+    for (const entry of fs14.readdirSync(dir, { withFileTypes: true })) {
+      const full = path7.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!skip?.has(entry.name)) {
           files.push(...walkMdFiles2(full, skip));
@@ -2840,7 +3168,7 @@ function loadFilesAsXml(dir, tag, skip) {
   }
   const sections = files.map((f) => {
     try {
-      const content = fs15.readFileSync(f, "utf-8").trim();
+      const content = fs14.readFileSync(f, "utf-8").trim();
       return `<file path="${f}">
 ${content}
 </file>`;
@@ -2909,38 +3237,11 @@ The first-party SDK (@mindstudio-ai/agent) provides access to 200+ AI models (Op
 </platform_brief>`;
 }
 
-// src/subagents/designExpert/prompt.ts
-var base3 = import.meta.dirname ?? path10.dirname(new URL(import.meta.url).pathname);
-function resolvePath2(filename) {
-  const local4 = path10.join(base3, filename);
-  return fs16.existsSync(local4) ? local4 : path10.join(base3, "subagents", "designExpert", filename);
-}
-function readFile(filename) {
-  return fs16.readFileSync(resolvePath2(filename), "utf-8").trim();
-}
-function readJson(filename, fallback) {
-  try {
-    return JSON.parse(fs16.readFileSync(resolvePath2(filename), "utf-8"));
-  } catch {
-    return fallback;
-  }
-}
-var RUNTIME_PLACEHOLDERS = /* @__PURE__ */ new Set([
-  "fonts_to_consider",
-  "inspiration_images"
-]);
-var PROMPT_TEMPLATE = readFile("prompt.md").replace(/\{\{([^}]+)\}\}/g, (match, key) => {
-  const k = key.trim();
-  return RUNTIME_PLACEHOLDERS.has(k) ? match : readFile(k);
-}).replace(/\n{3,}/g, "\n\n");
-var fontData = readJson("data/fonts.json", {
-  cssUrlPattern: "",
-  fonts: [],
-  pairings: []
-});
-var inspirationImages = readJson("data/inspiration.json", {
-  images: []
-}).images;
+// src/subagents/designExpert/data/getFontLibrarySample.ts
+var fontData = readJsonAsset(
+  { cssUrlPattern: "", fonts: [], pairings: [] },
+  "subagents/designExpert/data/sources/fonts.json"
+);
 function sample(arr, n) {
   if (arr.length <= n) {
     return [...arr];
@@ -2952,10 +3253,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") {
@@ -2971,35 +3274,72 @@ 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 a curated font library. Use these as starting points for font selection.
 
-A random sample from Fontshare, Open Foundry, and Google Fonts. Use these as starting points for font selection.
-CSS URL pattern: ${fontData.cssUrlPattern}
+### Fonts
 
 ${fontList}
 
-### Suggested pairings
+### Pairings
 
-${pairingList}
-</fonts_to_consider>` : "";
-  const imageList = images.map((img) => `- ${img.analysis}`).join("\n\n");
-  const inspirationSection = images.length ? `<design_inspiration>
-## Design inspiration
+${pairingList}`.trim();
+}
+
+// src/subagents/designExpert/data/getDesignReferencesSample.ts
+var inspirationImages = readJsonAsset(
+  { images: [] },
+  "subagents/designExpert/data/sources/inspiration.json"
+).images;
+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();
+}
+
+// src/subagents/designExpert/prompt.ts
+var SUBAGENT = "subagents/designExpert";
+var RUNTIME_PLACEHOLDERS = /* @__PURE__ */ new Set(["font_library", "design_references"]);
+var PROMPT_TEMPLATE = readAsset(SUBAGENT, "prompt.md").replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+  const k = key.trim();
+  return RUNTIME_PLACEHOLDERS.has(k) ? match : readAsset(SUBAGENT, k);
+}).replace(/\n{3,}/g, "\n\n");
+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 {
+    fs15.writeFileSync(`.design-prompt.md`, prompt);
+  } catch {
   }
   return prompt;
 }
@@ -3017,7 +3357,7 @@ var designExpertTool = {
       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"]
@@ -3032,14 +3372,15 @@ var designExpertTool = {
       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;
@@ -3145,8 +3486,8 @@ var VISION_TOOLS = [
 ];
 
 // src/subagents/productVision/executor.ts
-import fs17 from "fs";
-import path11 from "path";
+import fs16 from "fs";
+import path8 from "path";
 var ROADMAP_DIR = "src/roadmap";
 function formatRequires(requires) {
   return requires.length === 0 ? "[]" : `[${requires.map((r) => `"${r}"`).join(", ")}]`;
@@ -3162,10 +3503,10 @@ async function executeVisionTool(name, input) {
         requires,
         body
       } = input;
-      const filePath = path11.join(ROADMAP_DIR, `${slug}.md`);
+      const filePath = path8.join(ROADMAP_DIR, `${slug}.md`);
       try {
-        fs17.mkdirSync(ROADMAP_DIR, { recursive: true });
-        const oldContent = fs17.existsSync(filePath) ? fs17.readFileSync(filePath, "utf-8") : "";
+        fs16.mkdirSync(ROADMAP_DIR, { recursive: true });
+        const oldContent = fs16.existsSync(filePath) ? fs16.readFileSync(filePath, "utf-8") : "";
         const content = `---
 name: ${itemName}
 type: roadmap
@@ -3177,7 +3518,7 @@ requires: ${formatRequires(requires)}
 
 ${body}
 `;
-        fs17.writeFileSync(filePath, content, "utf-8");
+        fs16.writeFileSync(filePath, content, "utf-8");
         const lineCount = content.split("\n").length;
         const label = oldContent ? "Updated" : "Wrote";
         return `${label} ${filePath} (${lineCount} lines)
@@ -3188,12 +3529,12 @@ ${unifiedDiff(filePath, oldContent, content)}`;
     }
     case "updateRoadmapItem": {
       const { slug } = input;
-      const filePath = path11.join(ROADMAP_DIR, `${slug}.md`);
+      const filePath = path8.join(ROADMAP_DIR, `${slug}.md`);
       try {
-        if (!fs17.existsSync(filePath)) {
+        if (!fs16.existsSync(filePath)) {
           return `Error: ${filePath} does not exist`;
         }
-        const oldContent = fs17.readFileSync(filePath, "utf-8");
+        const oldContent = fs16.readFileSync(filePath, "utf-8");
         let content = oldContent;
         if (input.status) {
           content = content.replace(
@@ -3246,7 +3587,7 @@ ${input.appendHistory}
 `;
           }
         }
-        fs17.writeFileSync(filePath, content, "utf-8");
+        fs16.writeFileSync(filePath, content, "utf-8");
         const lineCount = content.split("\n").length;
         return `Updated ${filePath} (${lineCount} lines)
 ${unifiedDiff(filePath, oldContent, content)}`;
@@ -3256,13 +3597,13 @@ ${unifiedDiff(filePath, oldContent, content)}`;
     }
     case "deleteRoadmapItem": {
       const { slug } = input;
-      const filePath = path11.join(ROADMAP_DIR, `${slug}.md`);
+      const filePath = path8.join(ROADMAP_DIR, `${slug}.md`);
       try {
-        if (!fs17.existsSync(filePath)) {
+        if (!fs16.existsSync(filePath)) {
           return `Error: ${filePath} does not exist`;
         }
-        const oldContent = fs17.readFileSync(filePath, "utf-8");
-        fs17.unlinkSync(filePath);
+        const oldContent = fs16.readFileSync(filePath, "utf-8");
+        fs16.unlinkSync(filePath);
         return `Deleted ${filePath}
 ${unifiedDiff(filePath, oldContent, "")}`;
       } catch (err) {
@@ -3275,12 +3616,7 @@ ${unifiedDiff(filePath, oldContent, "")}`;
 }
 
 // src/subagents/productVision/prompt.ts
-import fs18 from "fs";
-import path12 from "path";
-var base4 = import.meta.dirname ?? path12.dirname(new URL(import.meta.url).pathname);
-var local2 = path12.join(base4, "prompt.md");
-var PROMPT_PATH2 = fs18.existsSync(local2) ? local2 : path12.join(base4, "subagents", "productVision", "prompt.md");
-var BASE_PROMPT2 = fs18.readFileSync(PROMPT_PATH2, "utf-8").trim();
+var BASE_PROMPT2 = readAsset("subagents/productVision", "prompt.md");
 function getProductVisionPrompt() {
   const specContext = loadSpecContext();
   const roadmapContext = loadRoadmapContext();
@@ -3326,17 +3662,14 @@ var productVisionTool = {
       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;
   }
 };
 
-// src/subagents/codeSanityCheck/index.ts
-import fs19 from "fs";
-import path13 from "path";
-
 // src/subagents/codeSanityCheck/tools.ts
 var SANITY_CHECK_TOOLS = [
   {
@@ -3429,10 +3762,7 @@ var SANITY_CHECK_TOOLS = [
 ];
 
 // src/subagents/codeSanityCheck/index.ts
-var base5 = import.meta.dirname ?? path13.dirname(new URL(import.meta.url).pathname);
-var local3 = path13.join(base5, "prompt.md");
-var PROMPT_PATH3 = fs19.existsSync(local3) ? local3 : path13.join(base5, "subagents", "codeSanityCheck", "prompt.md");
-var BASE_PROMPT3 = fs19.readFileSync(PROMPT_PATH3, "utf-8").trim();
+var BASE_PROMPT3 = readAsset("subagents/codeSanityCheck", "prompt.md");
 var codeSanityCheckTool = {
   definition: {
     name: "codeSanityCheck",
@@ -3470,7 +3800,8 @@ var codeSanityCheckTool = {
       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;
@@ -3482,7 +3813,7 @@ function getSpecTools() {
   return [readSpecTool, writeSpecTool, editSpecTool, listSpecFilesTool];
 }
 function getCodeTools() {
-  const tools = [
+  const tools2 = [
     readFileTool,
     writeFileTool,
     editFileTool,
@@ -3497,9 +3828,9 @@ function getCodeTools() {
     browserAutomationTool
   ];
   if (isLspConfigured()) {
-    tools.push(lspDiagnosticsTool, restartProcessTool);
+    tools2.push(lspDiagnosticsTool, restartProcessTool);
   }
-  return tools;
+  return tools2;
 }
 function getCommonTools() {
   return [
@@ -3559,11 +3890,11 @@ function executeTool(name, input, context) {
 }
 
 // src/session.ts
-import fs20 from "fs";
+import fs17 from "fs";
 var SESSION_FILE = ".remy-session.json";
 function loadSession(state) {
   try {
-    const raw = fs20.readFileSync(SESSION_FILE, "utf-8");
+    const raw = fs17.readFileSync(SESSION_FILE, "utf-8");
     const data = JSON.parse(raw);
     if (Array.isArray(data.messages) && data.messages.length > 0) {
       state.messages = sanitizeMessages(data.messages);
@@ -3611,7 +3942,7 @@ function sanitizeMessages(messages) {
 }
 function saveSession(state) {
   try {
-    fs20.writeFileSync(
+    fs17.writeFileSync(
       SESSION_FILE,
       JSON.stringify({ messages: state.messages }, null, 2),
       "utf-8"
@@ -3622,7 +3953,7 @@ function saveSession(state) {
 function clearSession(state) {
   state.messages = [];
   try {
-    fs20.unlinkSync(SESSION_FILE);
+    fs17.unlinkSync(SESSION_FILE);
   } catch {
   }
 }
@@ -3790,85 +4121,6 @@ function parsePartialJson(jsonString) {
   return parseAny();
 }
 
-// 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");
-    }
-  };
-}
-
 // src/errors.ts
 var patterns = [
   [
@@ -3932,13 +4184,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)
@@ -3985,6 +4238,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) {
@@ -4048,18 +4315,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(
         {
@@ -4067,7 +4322,7 @@ async function runTurn(params) {
           model,
           system,
           messages: cleanMessagesForApi(state.messages),
-          tools,
+          tools: tools2,
           signal
         },
         {
@@ -4180,10 +4435,9 @@ async function runTurn(params) {
       } else {
         throw err;
       }
-    } finally {
-      statusWatcher.stop();
     }
     if (signal?.aborted) {
+      statusWatcher.stop();
       if (contentBlocks.length > 0) {
         contentBlocks.push({
           type: "text",
@@ -4205,6 +4459,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;
@@ -4213,8 +4468,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") {
@@ -4223,80 +4477,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
@@ -4304,6 +4581,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;
@@ -4328,11 +4606,81 @@ async function runTurn(params) {
   }
 }
 
+// src/toolRegistry.ts
+var 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 BASE_DIR = import.meta.dirname ?? path14.dirname(new URL(import.meta.url).pathname);
-var ACTIONS_DIR = path14.join(BASE_DIR, "actions");
 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 };
@@ -4396,6 +4744,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",
@@ -4500,14 +4849,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(
@@ -4559,7 +4940,8 @@ async function startHeadless(opts = {}) {
         signal: currentAbort.signal,
         onEvent,
         resolveExternalTool,
-        hidden: isCommand
+        hidden: isCommand,
+        toolRegistry
       });
       if (!completedEmitted) {
         emit(
@@ -4613,6 +4995,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;