dominus-cli 0.6.0 → 2.0.0

package/dist/index.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
-import fs5, { existsSync, readFileSync, unlinkSync } from 'fs';
-import path4, { join } from 'path';
+import fs6, { existsSync, readFileSync, unlinkSync } from 'fs';
+import path5, { join } from 'path';
 import os3, { tmpdir } from 'os';
 import { nanoid } from 'nanoid';
 import { WebSocket, WebSocketServer } from 'ws';
 import { EventEmitter } from 'events';
+import OpenAI from 'openai';
 import initSqlJs from 'sql.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -17,7 +18,6 @@ import TextInput from 'ink-text-input';
 import { execSync } from 'child_process';
 import { randomBytes } from 'crypto';
 import Spinner from 'ink-spinner';
-import OpenAI from 'openai';
 import https from 'https';
 import { fileURLToPath } from 'url';
 
@@ -57,14 +57,14 @@ function resolveProviderSettings(config) {
   };
 }
 function ensureDir() {
-  if (!fs5.existsSync(DOMINUS_DIR)) {
-    fs5.mkdirSync(DOMINUS_DIR, { recursive: true });
+  if (!fs6.existsSync(DOMINUS_DIR)) {
+    fs6.mkdirSync(DOMINUS_DIR, { recursive: true });
   }
 }
 function readJson(filePath, defaults) {
   try {
-    if (fs5.existsSync(filePath)) {
-      const raw = fs5.readFileSync(filePath, "utf-8");
+    if (fs6.existsSync(filePath)) {
+      const raw = fs6.readFileSync(filePath, "utf-8");
       return { ...defaults, ...JSON.parse(raw) };
     }
   } catch {
@@ -73,7 +73,7 @@ function readJson(filePath, defaults) {
 }
 function writeJson(filePath, data) {
   ensureDir();
-  fs5.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+  fs6.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
 }
 function loadConfig() {
   ensureDir();
@@ -125,10 +125,10 @@ function createConfigAccess() {
 var DOMINUS_DIR, CONFIG_PATH, DB_PATH, RULES_PATH, PROVIDERS, DEFAULTS, DEFAULT_RULES;
 var init_config = __esm({
   "src/config/config.ts"() {
-    DOMINUS_DIR = path4.join(os3.homedir(), ".dominus");
-    CONFIG_PATH = path4.join(DOMINUS_DIR, "config.json");
-    DB_PATH = path4.join(DOMINUS_DIR, "dominus.db");
-    RULES_PATH = path4.join(DOMINUS_DIR, "rules.json");
+    DOMINUS_DIR = path5.join(os3.homedir(), ".dominus");
+    CONFIG_PATH = path5.join(DOMINUS_DIR, "config.json");
+    DB_PATH = path5.join(DOMINUS_DIR, "dominus.db");
+    RULES_PATH = path5.join(DOMINUS_DIR, "rules.json");
     PROVIDERS = {
       openai: {
         name: "OpenAI",
@@ -325,8 +325,8 @@ var init_ws_server = __esm({
         ws.on("close", () => {
           if (this.controllers.has(ws)) {
             this.controllers.delete(ws);
-            for (const [id, controllerWs] of this.relayRequests) {
-              if (controllerWs === ws) this.relayRequests.delete(id);
+            for (const [id, relay] of this.relayRequests) {
+              if (relay.controllerWs === ws) this.relayRequests.delete(id);
             }
           } else {
             const placeId = this.wsToPlaceId.get(ws);
@@ -337,12 +337,28 @@ var init_ws_server = __esm({
               this.emit("studio:disconnected", { placeId, placeName: conn?.placeName });
               this.broadcastToControllers("studio:disconnected", { placeId, placeName: conn?.placeName });
               for (const [id, pending] of this.pendingRequests) {
-                clearTimeout(pending.timer);
-                pending.reject(new Error(`Studio disconnected (place ${placeId})`));
-                this.pendingRequests.delete(id);
+                if (pending.targetWs === ws) {
+                  clearTimeout(pending.timer);
+                  pending.reject(new Error(`Studio disconnected (place ${placeId})`));
+                  this.pendingRequests.delete(id);
+                }
+              }
+              for (const [id, relay] of this.relayRequests) {
+                if (relay.targetWs === ws) {
+                  if (relay.controllerWs.readyState === WebSocket.OPEN) {
+                    relay.controllerWs.send(serializeMessage({
+                      id,
+                      type: StudioMsg.RESPONSE,
+                      payload: { error: `Studio disconnected (place ${placeId})` },
+                      ts: Date.now()
+                    }));
+                  }
+                  this.relayRequests.delete(id);
+                }
               }
               if (this.activePlaceId === placeId) {
                 this.activePlaceId = 0;
+                this.broadcastTargetState();
               }
             }
           }
@@ -361,6 +377,7 @@ var init_ws_server = __esm({
         }
         const conn = {
           ws,
+          connectionId: `${placeId}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`,
           connectedAt: Date.now(),
           studioVersion: payload.studioVersion,
           placeId,
@@ -368,8 +385,12 @@ var init_ws_server = __esm({
         };
         this.studioClients.set(placeId, conn);
         this.wsToPlaceId.set(ws, placeId);
-        this.emit("studio:connected", { ...payload, placeId });
-        this.broadcastToControllers("studio:connected", { ...payload, placeId });
+        if (this.studioClients.size === 1 && this.activePlaceId === 0) {
+          this.activePlaceId = placeId;
+        }
+        this.emit("studio:connected", { ...payload, placeId, connectionId: conn.connectionId });
+        this.broadcastToControllers("studio:connected", { ...payload, placeId, connectionId: conn.connectionId });
+        this.broadcastTargetState();
       }
       addController(ws) {
         this.controllers.add(ws);
@@ -384,6 +405,27 @@ var init_ws_server = __esm({
         }
       }
       handleControllerMessage(controllerWs, msg) {
+        if (msg.type === "controller:set_active_place") {
+          const payload = msg.payload;
+          try {
+            this.setActivePlaceId(Number(payload.placeId ?? 0));
+          } catch (err) {
+            controllerWs.send(serializeMessage({
+              id: msg.id,
+              type: StudioMsg.RESPONSE,
+              payload: { success: false, error: err instanceof Error ? err.message : String(err) },
+              ts: Date.now()
+            }));
+            return;
+          }
+          controllerWs.send(serializeMessage({
+            id: msg.id,
+            type: StudioMsg.RESPONSE,
+            payload: { success: true, activePlaceId: this.activePlaceId, connections: this.listConnections() },
+            ts: Date.now()
+          }));
+          return;
+        }
         const target = this.resolveTarget();
         if (!target || target.ws.readyState !== WebSocket.OPEN) {
           controllerWs.send(serializeMessage({
@@ -394,7 +436,11 @@ var init_ws_server = __esm({
           }));
           return;
         }
-        this.relayRequests.set(msg.id, controllerWs);
+        this.relayRequests.set(msg.id, {
+          controllerWs,
+          targetWs: target.ws,
+          targetPlaceId: target.placeId ?? 0
+        });
         target.ws.send(serializeMessage(msg));
       }
       handleStudioMessage(ws, msg) {
@@ -414,14 +460,25 @@ var init_ws_server = __esm({
           return;
         }
         if (msg.type === StudioMsg.RESPONSE) {
-          const controllerWs = this.relayRequests.get(msg.id);
-          if (controllerWs && controllerWs.readyState === WebSocket.OPEN) {
-            controllerWs.send(serializeMessage(msg));
+          if (!this.wsToPlaceId.has(ws)) return;
+          const relay = this.relayRequests.get(msg.id);
+          if (relay) {
+            if (relay.targetWs !== ws) {
+              this.emit("server:error", new Error(`Ignoring relayed response ${msg.id} from non-target Studio`));
+              return;
+            }
+            if (relay.controllerWs.readyState === WebSocket.OPEN) {
+              relay.controllerWs.send(serializeMessage(msg));
+            }
             this.relayRequests.delete(msg.id);
             return;
           }
           const pending = this.pendingRequests.get(msg.id);
           if (pending) {
+            if (pending.targetWs !== ws) {
+              this.emit("server:error", new Error(`Ignoring response ${msg.id} from non-target Studio`));
+              return;
+            }
             clearTimeout(pending.timer);
             pending.resolve(msg);
             this.pendingRequests.delete(msg.id);
@@ -471,7 +528,9 @@ var init_ws_server = __esm({
           this.pendingRequests.set(msg.id, {
             resolve,
             reject,
-            timer
+            timer,
+            targetWs: target.ws,
+            targetPlaceId: target.placeId ?? 0
           });
           target.ws.send(serializeMessage(msg));
         });
@@ -491,16 +550,28 @@ var init_ws_server = __esm({
       listConnections() {
         return [...this.studioClients.values()].filter((c) => c.ws.readyState === WebSocket.OPEN).map((c) => ({
           placeId: c.placeId ?? 0,
+          connectionId: c.connectionId,
           placeName: c.placeName,
           studioVersion: c.studioVersion,
-          connectedAt: c.connectedAt
+          connectedAt: c.connectedAt,
+          active: this.activePlaceId === 0 && this.studioClients.size === 1 || c.placeId === this.activePlaceId
         }));
       }
       getActivePlaceId() {
         return this.activePlaceId;
       }
       setActivePlaceId(placeId) {
+        if (placeId !== 0 && !this.studioClients.has(placeId)) {
+          throw new Error(`Place ${placeId} is not connected`);
+        }
         this.activePlaceId = placeId;
+        this.broadcastTargetState();
+      }
+      broadcastTargetState() {
+        this.broadcastToControllers("controller:target_state", {
+          activePlaceId: this.activePlaceId,
+          connections: this.listConnections()
+        });
       }
       getPort() {
         return this.port;
@@ -532,6 +603,15 @@ var init_ws_server = __esm({
     };
   }
 });
+function toConnectionInfo(c) {
+  return {
+    connectedAt: c.connectedAt,
+    connectionId: c.connectionId,
+    studioVersion: c.studioVersion,
+    placeId: c.placeId,
+    placeName: c.placeName
+  };
+}
 async function isPortInUse(port) {
   return new Promise((resolve) => {
     const ws = new WebSocket(`ws://localhost:${port}`);
@@ -606,12 +686,7 @@ var init_ws_client = __esm({
           if (p.connections) {
             this.connections.clear();
             for (const c of p.connections) {
-              this.connections.set(c.placeId, {
-                connectedAt: c.connectedAt,
-                studioVersion: c.studioVersion,
-                placeId: c.placeId,
-                placeName: c.placeName
-              });
+              this.connections.set(c.placeId, toConnectionInfo(c));
             }
           }
           if (p.activePlaceId !== void 0) {
@@ -622,12 +697,19 @@ var init_ws_client = __esm({
           }
           return;
         }
+        if (msg.type === "controller:target_state") {
+          const payload = msg.payload;
+          this.applyTargetState(payload);
+          this.emit("controller:target_state", payload);
+          return;
+        }
         if (msg.type === "studio:connected") {
           this.studioConnected = true;
           const payload = msg.payload;
           const placeId = payload.placeId ?? 0;
           this.connections.set(placeId, {
             connectedAt: Date.now(),
+            connectionId: payload.connectionId ?? `${placeId}`,
             studioVersion: payload.studioVersion,
             placeId,
             placeName: payload.placeName
@@ -645,6 +727,7 @@ var init_ws_client = __esm({
           if (this.activePlaceId === placeId) {
             this.activePlaceId = 0;
           }
+          this.studioConnected = this.resolveTargetInfo() !== null;
           this.emit("studio:disconnected", payload);
           return;
         }
@@ -689,27 +772,57 @@ var init_ws_client = __esm({
         this.ws.send(serializeMessage(msg));
       }
       isConnected() {
-        return this.studioConnected && this.connections.size > 0;
+        return this.resolveTargetInfo() !== null;
       }
       getConnectionInfo() {
-        if (this.connections.size === 0) return null;
-        const target = this.activePlaceId !== 0 ? this.connections.get(this.activePlaceId) : this.connections.values().next().value;
+        const target = this.resolveTargetInfo();
         if (!target) return null;
         return { ...target, ws: this.ws };
       }
       listConnections() {
         return [...this.connections.values()].map((c) => ({
           placeId: c.placeId ?? 0,
+          connectionId: c.connectionId,
           placeName: c.placeName,
           studioVersion: c.studioVersion,
-          connectedAt: c.connectedAt
+          connectedAt: c.connectedAt,
+          active: this.activePlaceId === 0 && this.connections.size === 1 || c.placeId === this.activePlaceId
         }));
       }
       getActivePlaceId() {
         return this.activePlaceId;
       }
       setActivePlaceId(placeId) {
+        if (placeId !== 0 && !this.connections.has(placeId)) {
+          throw new Error(`Place ${placeId} is not connected`);
+        }
         this.activePlaceId = placeId;
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          const msg = createMessage("controller:set_active_place", { placeId });
+          this.ws.send(serializeMessage(msg));
+        }
+      }
+      applyTargetState(payload) {
+        if (payload.activePlaceId !== void 0) {
+          this.activePlaceId = payload.activePlaceId;
+        }
+        if (payload.connections) {
+          this.connections.clear();
+          for (const c of payload.connections) {
+            this.connections.set(c.placeId, toConnectionInfo(c));
+          }
+        }
+        this.studioConnected = this.resolveTargetInfo() !== null;
+      }
+      resolveTargetInfo() {
+        if (this.connections.size === 0) return null;
+        if (this.activePlaceId !== 0) {
+          return this.connections.get(this.activePlaceId) ?? null;
+        }
+        if (this.connections.size === 1) {
+          return this.connections.values().next().value ?? null;
+        }
+        return null;
       }
       getPort() {
         return this.port;
@@ -731,6 +844,148 @@ var init_ws_client = __esm({
     };
   }
 });
+function toolToOpenAI(tool31) {
+  return {
+    type: "function",
+    function: {
+      name: tool31.name,
+      description: tool31.description,
+      parameters: tool31.parameters
+    }
+  };
+}
+var AIProvider;
+var init_provider = __esm({
+  "src/ai/provider.ts"() {
+    init_config();
+    AIProvider = class {
+      client;
+      model;
+      providerName;
+      constructor(config) {
+        if (!config.apiKey) {
+          throw new Error("API key not configured. Run: dominus config set apiKey <your-key>");
+        }
+        const { baseUrl, model } = resolveProviderSettings(config);
+        this.providerName = PROVIDERS[config.provider]?.name ?? config.provider;
+        this.client = new OpenAI({
+          apiKey: config.apiKey,
+          baseURL: baseUrl
+        });
+        this.model = model;
+      }
+      setModel(model) {
+        this.model = model;
+      }
+      getModel() {
+        return this.model;
+      }
+      getProviderName() {
+        return this.providerName;
+      }
+      async listModels() {
+        try {
+          const list = await this.client.models.list();
+          const models = [];
+          for await (const m of list) {
+            models.push({ id: m.id, owned_by: m.owned_by });
+          }
+          models.sort((a, b) => a.id.localeCompare(b.id));
+          return models;
+        } catch {
+          return [];
+        }
+      }
+      async chat(messages, tools) {
+        const openAITools = tools?.map(toolToOpenAI);
+        const response = await this.client.chat.completions.create({
+          model: this.model,
+          messages,
+          tools: openAITools?.length ? openAITools : void 0,
+          temperature: 0.3
+        });
+        const choice = response.choices[0];
+        if (!choice) throw new Error("No response from AI");
+        const toolCalls = (choice.message.tool_calls ?? []).map((tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          arguments: JSON.parse(tc.function.arguments)
+        }));
+        return {
+          content: choice.message.content,
+          toolCalls,
+          finishReason: choice.finish_reason ?? "stop",
+          usage: response.usage ? {
+            promptTokens: response.usage.prompt_tokens,
+            completionTokens: response.usage.completion_tokens,
+            totalTokens: response.usage.total_tokens
+          } : void 0
+        };
+      }
+      async *streamChat(messages, tools) {
+        const openAITools = tools?.map(toolToOpenAI);
+        const stream = await this.client.chat.completions.create({
+          model: this.model,
+          messages,
+          tools: openAITools?.length ? openAITools : void 0,
+          temperature: 0.3,
+          stream: true
+        });
+        const toolCallBuffers = /* @__PURE__ */ new Map();
+        for await (const chunk of stream) {
+          const delta = chunk.choices[0]?.delta;
+          if (!delta) continue;
+          if (delta.content) {
+            yield { type: "text", content: delta.content };
+          }
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              if (!toolCallBuffers.has(tc.index)) {
+                toolCallBuffers.set(tc.index, {
+                  id: tc.id ?? "",
+                  name: tc.function?.name ?? "",
+                  args: ""
+                });
+                if (tc.function?.name) {
+                  yield {
+                    type: "tool_call_start",
+                    toolCall: { id: tc.id, name: tc.function.name }
+                  };
+                }
+              }
+              const buffer = toolCallBuffers.get(tc.index);
+              if (tc.id) buffer.id = tc.id;
+              if (tc.function?.name) buffer.name = tc.function.name;
+              if (tc.function?.arguments) {
+                buffer.args += tc.function.arguments;
+                yield {
+                  type: "tool_call_delta",
+                  content: tc.function.arguments,
+                  toolCall: { id: buffer.id, name: buffer.name }
+                };
+              }
+            }
+          }
+          if (chunk.choices[0]?.finish_reason === "tool_calls") {
+            for (const [, buffer] of toolCallBuffers) {
+              let args = {};
+              try {
+                args = JSON.parse(buffer.args);
+              } catch {
+              }
+              yield {
+                type: "tool_call_end",
+                toolCall: { id: buffer.id, name: buffer.name, arguments: args }
+              };
+            }
+            toolCallBuffers.clear();
+          }
+        }
+        yield { type: "done" };
+      }
+    };
+  }
+});
 
 // src/agent/internal-memory.ts
 var INTERNAL_MEMORY;
@@ -796,6 +1051,8 @@ These are built-in lessons that ship with Dominus. Follow them exactly.
 - Converting UI to Roact/React \u2192 use \`convert_ui_to_code\`
 - Creating instances \u2192 use \`create_part\`, \`create_ui\`, \`insert_instance\`, \`build_multiple\`
 - Modifying properties \u2192 use \`set_properties\` or \`bulk_set_properties\`
+- Bulk font/style/scaling changes \u2192 use \`bulk_set_properties\` with filter mode (root + className + properties)
+- Adding UIStroke/UICorner to many instances \u2192 use \`bulk_set_properties\` with \`addChildren\` (idempotent)
 - Reading scripts \u2192 use \`read_script\`
 - Browsing the explorer \u2192 use \`get_explorer\`
 \`run_code\` is ONLY for procedural logic, terrain generation, raycasts, physics queries, or custom algorithms with no tool equivalent.
@@ -805,6 +1062,19 @@ These are built-in lessons that ship with Dominus. Follow them exactly.
 - \`inspect_instance\` \u2014 Returns compact properties + children tree for a single instance in ONE call. Combines get_properties + get_explorer.
 - \`convert_ui_to_code\` \u2014 Serializes a UI tree and generates a Roact/React component. Use when user says "turn this into a component" or "convert to React".
 
+### UI Pre-Flight \u2014 ASK BEFORE BUILDING
+Before creating any non-trivial UI (more than a single element), **ask the user these questions** to avoid rework:
+- **A) Device scaling** \u2014 "Should this UI scale for mobile/tablet, or is it PC-only?"
+  - Mobile: use Scale-based sizing, UIAspectRatioConstraint, TextScaled or AutomaticSize, avoid large pixel offsets.
+  - PC-only: pixel offsets are fine.
+- **B) ScreenGui structure** \u2014 "All panels in one ScreenGui, or separate ScreenGuis per panel?"
+  - One: simpler, easy to toggle all at once.
+  - Separate: independent ZIndex, modular show/hide.
+- **C) Font & style** \u2014 "Any preferred font, color scheme, or style reference?"
+  - Default to Roboto if user has no preference. Use FontFace with Weight=Bold for bold.
+  - Match screenshots closely (transparency, stroke, spacing).
+- Skip these only if the user already specified preferences or the task is trivially small.
+
 ### Verification habits
 - After a build, call \`get_explorer\` or \`get_selection\` to confirm the tree looks right.
 - After editing a script, read it back.
@@ -851,14 +1121,14 @@ __export(store_exports, {
 function persist() {
   if (!db) return;
   const data = db.export();
-  fs5.writeFileSync(dbPath, Buffer.from(data));
+  fs6.writeFileSync(dbPath, Buffer.from(data));
 }
 async function initMemoryStore() {
   if (db) return;
   dbPath = getDbPath();
   const SQL = await initSqlJs();
-  if (fs5.existsSync(dbPath)) {
-    const buffer = fs5.readFileSync(dbPath);
+  if (fs6.existsSync(dbPath)) {
+    const buffer = fs6.readFileSync(dbPath);
     db = new SQL.Database(buffer);
   } else {
     db = new SQL.Database();
@@ -1123,109 +1393,958 @@ CREATE INDEX IF NOT EXISTS idx_summaries_project ON summaries(project_id);
   }
 });
 
-// src/tools/studio/read-script.ts
-var read_script_exports = {};
-__export(read_script_exports, {
-  tool: () => tool
-});
-var tool;
-var init_read_script = __esm({
-  "src/tools/studio/read-script.ts"() {
-    init_protocol();
-    tool = {
-      name: "read_script",
-      description: 'Read the source code of a script in Roblox Studio. Provide the full instance path (e.g., "ServerScriptService.GameManager").',
-      parameters: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: 'Full instance path of the script (e.g., "ServerScriptService.GameManager")'
-          }
-        },
-        required: ["path"]
-      },
-      async execute(params, ctx) {
-        if (!ctx.isStudioConnected()) {
-          return { success: false, error: "Studio is not connected" };
-        }
-        const path5 = params.path;
-        const response = await ctx.sendToStudio(CliMsg.GET_SCRIPT, { path: path5 });
-        if (!response.payload) {
-          return { success: false, error: `Script not found: ${path5}` };
-        }
-        return {
-          success: true,
-          data: {
-            path: response.payload.path,
-            className: response.payload.className,
-            source: response.payload.source,
-            lineCount: response.payload.lineCount
-          }
-        };
+// src/agent/json-response.ts
+function parseJsonResponse(content) {
+  if (!content) return null;
+  const trimmed = content.trim();
+  const candidates = [
+    trimmed,
+    ...extractMarkdownJsonBlocks(trimmed),
+    ...extractBalancedJsonBlocks(trimmed)
+  ];
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+    }
+  }
+  return null;
+}
+function extractMarkdownJsonBlocks(content) {
+  const matches = content.match(/```(?:json)?\s*([\s\S]*?)```/gi) ?? [];
+  return matches.map((block) => block.replace(/```(?:json)?/i, "").replace(/```$/, "").trim()).filter(Boolean);
+}
+function extractBalancedJsonBlocks(content) {
+  const blocks = [];
+  const openers = ["{", "["];
+  for (let start = 0; start < content.length; start++) {
+    if (!openers.includes(content[start])) continue;
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (let end = start; end < content.length; end++) {
+      const ch = content[end];
+      if (escapeNext) {
+        escapeNext = false;
+        continue;
       }
-    };
+      if (ch === "\\") {
+        escapeNext = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === "{" || ch === "[") depth++;
+      if (ch === "}" || ch === "]") depth--;
+      if (depth === 0) {
+        blocks.push(content.slice(start, end + 1).trim());
+        break;
+      }
+    }
+  }
+  return blocks;
+}
+var init_json_response = __esm({
+  "src/agent/json-response.ts"() {
   }
 });
 
-// src/tools/studio/edit-script.ts
-var edit_script_exports = {};
-__export(edit_script_exports, {
-  tool: () => tool2
-});
-var tool2;
-var init_edit_script = __esm({
-  "src/tools/studio/edit-script.ts"() {
-    init_protocol();
-    tool2 = {
-      name: "edit_script",
-      description: "Replace the entire source code of a script in Roblox Studio. Provide the full path and the new source code.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "Full instance path of the script"
-          },
-          source: {
-            type: "string",
-            description: "The new complete source code for the script"
-          }
-        },
-        required: ["path", "source"]
-      },
-      async execute(params, ctx) {
-        if (!ctx.isStudioConnected()) {
-          return { success: false, error: "Studio is not connected" };
+// src/agent/verifier.ts
+async function verifyAction(check, ctx) {
+  switch (check.type) {
+    case "script_edit":
+      return verifyScriptEdit(check.path, check.expectedContent, ctx);
+    case "code_run":
+      return verifyCodeRun(ctx);
+    case "instance_create":
+      return verifyInstanceExists(check.path, ctx);
+    case "property_set":
+      return verifyPropertySet(check.path, check.expectedProperties ?? {}, ctx);
+    default:
+      return { success: true };
+  }
+}
+function inferVerifyChecks(call, result) {
+  if (!result.success) return [];
+  switch (call.name) {
+    case "edit_script":
+      return [
+        {
+          type: "script_edit",
+          path: typeof call.arguments.path === "string" ? call.arguments.path : void 0,
+          expectedContent: typeof call.arguments.source === "string" ? call.arguments.source : void 0
         }
-        const path5 = params.path;
-        const source = params.source;
-        const response = await ctx.sendToStudio(CliMsg.SET_SCRIPT, { path: path5, source });
-        const payload = response.payload;
-        if (!payload.success) {
-          return { success: false, error: payload.error ?? "Failed to edit script" };
+      ];
+    case "run_code":
+    case "execute_run_test":
+    case "execute_play_test":
+      return [{ type: "code_run" }];
+    case "create_ui":
+    case "create_part":
+    case "clone_instance":
+    case "insert_instance":
+    case "group_instances": {
+      const createdPath = extractPath(result.data) ?? extractStringArg(call.arguments, "path");
+      return createdPath ? [{ type: "instance_create", path: createdPath }] : [];
+    }
+    case "set_properties":
+      return [
+        {
+          type: "property_set",
+          path: extractStringArg(call.arguments, "path"),
+          expectedProperties: asRecord(call.arguments.properties)
+        }
+      ];
+    case "bulk_set_properties": {
+      const path6 = extractPath(result.data) ?? extractStringArg(call.arguments, "path");
+      const properties = asRecord(call.arguments.properties);
+      return path6 && properties ? [{ type: "property_set", path: path6, expectedProperties: properties }] : [];
+    }
+    default:
+      return [];
+  }
+}
+async function verifyScriptEdit(scriptPath, expectedContent, ctx) {
+  if (!ctx.isStudioConnected()) {
+    return { success: false, error: "Studio disconnected during verification" };
+  }
+  try {
+    const response = await ctx.sendToStudio(CliMsg.GET_SCRIPT, {
+      path: scriptPath
+    });
+    if (!response.payload?.source) {
+      return { success: false, error: `Could not read back script: ${scriptPath}` };
+    }
+    if (expectedContent && response.payload.source !== expectedContent) {
+      return {
+        success: false,
+        error: "Script content does not match expected output",
+        data: {
+          expected: expectedContent.slice(0, 200),
+          actual: response.payload.source.slice(0, 200)
         }
-        return { success: true, data: { path: path5, linesWritten: source.split("\n").length } };
+      };
+    }
+    return { success: true, data: { verified: scriptPath } };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Verification failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function verifyCodeRun(ctx) {
+  if (!ctx.isStudioConnected()) {
+    return { success: false, error: "Studio disconnected during verification" };
+  }
+  try {
+    const response = await ctx.sendToStudio(
+      CliMsg.GET_OUTPUT,
+      { limit: 5, level: "error" }
+    );
+    const errors = response.payload?.entries?.filter((e) => e.level === "error") ?? [];
+    if (errors.length > 0) {
+      return {
+        success: false,
+        error: "Errors detected after code execution",
+        data: { errors: errors.map((e) => e.message) }
+      };
+    }
+    return { success: true };
+  } catch {
+    return { success: true };
+  }
+}
+async function verifyInstanceExists(instancePath, ctx) {
+  if (!ctx.isStudioConnected()) {
+    return { success: false, error: "Studio disconnected during verification" };
+  }
+  try {
+    const response = await ctx.sendToStudio(CliMsg.RUN_CODE, {
+      code: buildInstanceExistsCode(instancePath)
+    });
+    if (response.payload.error) {
+      return { success: false, error: `Instance verification failed: ${response.payload.error}` };
+    }
+    const exists = String(response.payload.output ?? "").trim().toLowerCase();
+    if (!exists.includes("true")) {
+      return { success: false, error: `Instance not found after creation: ${instancePath}` };
+    }
+    return { success: true, data: { exists: instancePath } };
+  } catch {
+    return { success: true };
+  }
+}
+async function verifyPropertySet(instancePath, expectedProperties, ctx) {
+  if (!ctx.isStudioConnected()) {
+    return { success: false, error: "Studio disconnected during verification" };
+  }
+  if (!instancePath || Object.keys(expectedProperties).length === 0) {
+    return { success: true, data: { verified: instancePath } };
+  }
+  try {
+    const response = await ctx.sendToStudio(CliMsg.GET_PROPERTIES, {
+      path: instancePath,
+      compact: false
+    });
+    const entries = response.payload?.properties ?? [];
+    const byName = new Map(entries.map((entry) => [entry.name, entry.value]));
+    const mismatches = [];
+    for (const [name, expected] of Object.entries(expectedProperties)) {
+      const actual = byName.get(name);
+      if (actual == null) {
+        mismatches.push(`${name}: missing`);
+        continue;
+      }
+      if (!matchesPropertyValue(actual, expected)) {
+        mismatches.push(`${name}: expected ${stringifyExpected(expected)}, got ${actual}`);
       }
+    }
+    if (mismatches.length > 0) {
+      return {
+        success: false,
+        error: "Property verification failed",
+        data: { path: instancePath, mismatches }
+      };
+    }
+    return {
+      success: true,
+      data: { verified: instancePath, properties: Object.keys(expectedProperties) }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Property verification failed: ${err instanceof Error ? err.message : String(err)}`
     };
   }
+}
+function extractPath(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const candidate = data.path;
+  return typeof candidate === "string" ? candidate : void 0;
+}
+function extractStringArg(args, key) {
+  const value = args[key];
+  return typeof value === "string" ? value : void 0;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function buildInstanceExistsCode(instancePath) {
+  const parts = instancePath.split(".").filter(Boolean);
+  const lines = ["local node = game"];
+  for (const part of parts) {
+    lines.push(`node = node and node:FindFirstChild(${luaString(part)})`);
+  }
+  lines.push("return node ~= nil");
+  return lines.join("\n");
+}
+function luaString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function matchesPropertyValue(actual, expected) {
+  const normalizedActual = normalizeValue(actual);
+  if (typeof expected === "boolean" || typeof expected === "number") {
+    return normalizedActual === normalizeValue(String(expected));
+  }
+  if (typeof expected === "string") {
+    const normalizedExpected = normalizeValue(expected);
+    return normalizedActual === normalizedExpected || normalizedActual.includes(normalizedExpected);
+  }
+  if (Array.isArray(expected)) {
+    const normalizedExpected = normalizeValue(expected.join(","));
+    return normalizedActual.includes(normalizedExpected);
+  }
+  if (expected && typeof expected === "object") {
+    const compactExpected = normalizeValue(JSON.stringify(expected));
+    return normalizedActual.includes(compactExpected);
+  }
+  return true;
+}
+function normalizeValue(value) {
+  return value.replace(/[\s{}\[\]"]/g, "").toLowerCase();
+}
+function stringifyExpected(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+var init_verifier = __esm({
+  "src/agent/verifier.ts"() {
+    init_protocol();
+  }
 });
 
-// src/tools/studio/run-code.ts
-var run_code_exports = {};
-__export(run_code_exports, {
-  tool: () => tool3
-});
-var tool3;
-var init_run_code = __esm({
-  "src/tools/studio/run-code.ts"() {
-    init_protocol();
-    tool3 = {
-      name: "run_code",
-      description: "Execute arbitrary Luau code in Roblox Studio and return the output. The code runs in the Studio plugin context with full API access.",
-      parameters: {
-        type: "object",
-        properties: {
+// src/agent/multi-agent/conflicts.ts
+function normalizeScopePath(pathValue) {
+  return pathValue.trim().replace(/\[(?:"|')([^"']+)(?:"|')\]/g, ".$1").replace(/^game\./i, "").replace(/\.+/g, ".").replace(/^\./, "").replace(/\.$/, "");
+}
+function pathsOverlap(a, b) {
+  const left = normalizeScopePath(a).toLowerCase();
+  const right = normalizeScopePath(b).toLowerCase();
+  if (!left || !right) return false;
+  return left === right || left.startsWith(`${right}.`) || right.startsWith(`${left}.`);
+}
+function isPathWithinScopes(pathValue, scopes) {
+  const target = normalizeScopePath(pathValue).toLowerCase();
+  if (!target) return scopes.length === 0;
+  return scopes.some((scope) => {
+    const normalizedScope = normalizeScopePath(scope).toLowerCase();
+    return target === normalizedScope || target.startsWith(`${normalizedScope}.`);
+  });
+}
+function inferTargetPath(call) {
+  if (call.targetPath) return call.targetPath;
+  const args = call.args ?? {};
+  for (const key of ["path", "root", "rootPath", "parent", "parentPath"]) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  const targets = args.targets;
+  if (Array.isArray(targets)) {
+    const first = targets.find(
+      (target) => target && typeof target === "object" && typeof target.path === "string"
+    );
+    if (first?.path) return first.path;
+  }
+  return void 0;
+}
+function validateWorkerProposal(assignment, proposal) {
+  const errors = [];
+  if (proposal.workerId !== assignment.id) {
+    errors.push(`Proposal workerId "${proposal.workerId}" does not match assignment "${assignment.id}"`);
+  }
+  if (!proposal.summary?.trim()) {
+    errors.push("Proposal summary is required");
+  }
+  for (const call of proposal.proposedToolCalls ?? []) {
+    if (FORBIDDEN_WORKER_WRITE_TOOL_NAMES.has(call.tool)) {
+      errors.push(`Worker proposed forbidden write tool "${call.tool}"`);
+      continue;
+    }
+    if (!COORDINATOR_WRITE_TOOL_NAMES.has(call.tool)) {
+      errors.push(`Worker proposed unsupported coordinator write tool "${call.tool}"`);
+      continue;
+    }
+    const targetPath = inferTargetPath(call);
+    if (!targetPath) {
+      errors.push(`Proposed ${call.tool} call is missing a target path`);
+      continue;
+    }
+    if (!isPathWithinScopes(targetPath, assignment.ownedScopes)) {
+      errors.push(`Proposed ${call.tool} target "${targetPath}" is outside owned scopes`);
+    }
+  }
+  return errors;
+}
+function rejectConflictingAcceptedProposals(accepted) {
+  const finalAccepted = [];
+  const rejected = [];
+  const claimed = [];
+  for (const item of accepted) {
+    const conflict = findConflict(item.proposal, claimed);
+    if (conflict) {
+      rejected.push({
+        workerId: item.workerId,
+        proposal: item.proposal,
+        reason: `Conflicts with accepted worker ${conflict.workerId} on ${conflict.path}`
+      });
+      continue;
+    }
+    finalAccepted.push(item);
+    for (const call of item.proposal.proposedToolCalls) {
+      const targetPath = inferTargetPath(call);
+      if (targetPath) claimed.push({ workerId: item.workerId, path: targetPath });
+    }
+  }
+  return { accepted: finalAccepted, rejected };
+}
+function findConflict(proposal, claimed) {
+  for (const call of proposal.proposedToolCalls) {
+    const targetPath = inferTargetPath(call);
+    if (!targetPath) continue;
+    for (const existing of claimed) {
+      if (pathsOverlap(targetPath, existing.path)) return existing;
+    }
+  }
+  return null;
+}
+var READ_ONLY_TOOL_NAMES, COORDINATOR_WRITE_TOOL_NAMES, FORBIDDEN_WORKER_WRITE_TOOL_NAMES;
+var init_conflicts = __esm({
+  "src/agent/multi-agent/conflicts.ts"() {
+    READ_ONLY_TOOL_NAMES = /* @__PURE__ */ new Set([
+      "get_explorer",
+      "get_properties",
+      "get_descendants_properties",
+      "get_selection",
+      "search_scripts",
+      "read_script",
+      "get_output",
+      "get_class_info",
+      "serialize_ui",
+      "recall_memory",
+      "search_roblox_api",
+      "get_roblox_api_reference"
+    ]);
+    COORDINATOR_WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
+      "create_ui",
+      "set_properties",
+      "bulk_set_properties",
+      "insert_instance",
+      "move_instance"
+    ]);
+    FORBIDDEN_WORKER_WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
+      "run_code",
+      "edit_script",
+      "delete_instance",
+      "create_part",
+      "build_multiple",
+      "clone_instance",
+      "group_instances",
+      "find_replace_scripts",
+      "undo",
+      "redo"
+    ]);
+  }
+});
+
+// src/agent/multi-agent/worker.ts
+function buildWorkerPrompt(goal, assignment) {
+  return [
+    "You are a Dominus worker agent. You are not the coordinator.",
+    "You may inspect and reason, but you must not mutate Roblox Studio.",
+    "Use only the read tools provided to gather evidence.",
+    "Your final answer must be JSON only with this shape:",
+    '{"workerId":"...","summary":"...","evidence":[{"source":"...","summary":"...","data":{}}],"proposedToolCalls":[{"tool":"set_properties","args":{},"targetPath":"...","rationale":"..."}],"risks":["..."],"verificationSuggestions":["..."]}',
+    "",
+    `Global goal: ${goal}`,
+    `Worker id: ${assignment.id}`,
+    `Role: ${assignment.role}`,
+    `Objective: ${assignment.objective}`,
+    `Owned scopes: ${assignment.ownedScopes.join(", ") || "(none)"}`,
+    `Allowed read tools: ${assignment.allowedReadTools.join(", ")}`,
+    "Acceptance criteria:",
+    ...assignment.acceptanceCriteria.map((criterion) => `- ${criterion}`),
+    "",
+    "Proposal rules:",
+    "- Propose only coordinator-owned write tools: create_ui, set_properties, bulk_set_properties, insert_instance, move_instance.",
+    "- Every proposed write must include targetPath and stay inside your owned scopes.",
+    "- If you need no changes, return proposedToolCalls as an empty array and explain why."
+  ].join("\n");
+}
+function normalizeProposal(workerId, parsed) {
+  if (!parsed || typeof parsed !== "object") return null;
+  return {
+    workerId: typeof parsed.workerId === "string" ? parsed.workerId : workerId,
+    summary: typeof parsed.summary === "string" ? parsed.summary : "",
+    evidence: Array.isArray(parsed.evidence) ? parsed.evidence.map((item) => ({
+      source: String(item?.source ?? "worker"),
+      summary: String(item?.summary ?? ""),
+      data: item?.data
+    })) : [],
+    proposedToolCalls: Array.isArray(parsed.proposedToolCalls) ? parsed.proposedToolCalls.map((call) => ({
+      tool: String(call?.tool ?? ""),
+      args: call?.args && typeof call.args === "object" ? call.args : {},
+      targetPath: typeof call?.targetPath === "string" ? call.targetPath : void 0,
+      rationale: typeof call?.rationale === "string" ? call.rationale : void 0
+    })) : [],
+    risks: Array.isArray(parsed.risks) ? parsed.risks.map(String) : [],
+    verificationSuggestions: Array.isArray(parsed.verificationSuggestions) ? parsed.verificationSuggestions.map(String) : []
+  };
+}
+var WorkerAgent;
+var init_worker = __esm({
+  "src/agent/multi-agent/worker.ts"() {
+    init_json_response();
+    WorkerAgent = class {
+      constructor(ai, tools, toolCtx) {
+        this.ai = ai;
+        this.tools = tools;
+        this.toolCtx = toolCtx;
+      }
+      async run(goal, assignment) {
+        const messages = [
+          {
+            role: "system",
+            content: buildWorkerPrompt(goal, assignment)
+          }
+        ];
+        const toolResults = [];
+        for (let iteration = 0; iteration < 4; iteration++) {
+          const response = await this.ai.chat(messages, this.tools);
+          const assistantMessage = {
+            role: "assistant",
+            content: response.content ?? null,
+            ...response.toolCalls.length > 0 ? {
+              tool_calls: response.toolCalls.map((call) => ({
+                id: call.id,
+                type: "function",
+                function: { name: call.name, arguments: JSON.stringify(call.arguments) }
+              }))
+            } : {}
+          };
+          messages.push(assistantMessage);
+          if (response.toolCalls.length === 0) {
+            const proposal = normalizeProposal(
+              assignment.id,
+              parseJsonResponse(response.content)
+            );
+            if (!proposal) {
+              return {
+                assignment,
+                error: "Worker did not return a valid WorkerProposal JSON object",
+                toolResults
+              };
+            }
+            return { assignment, proposal, toolResults };
+          }
+          for (const call of response.toolCalls) {
+            const tool31 = this.tools.find((candidate) => candidate.name === call.name);
+            const result = tool31 ? await tool31.execute(call.arguments, this.toolCtx) : { success: false, error: `Read-only worker cannot use tool: ${call.name}` };
+            toolResults.push({ call, result });
+            messages.push({
+              role: "tool",
+              content: JSON.stringify(result),
+              tool_call_id: call.id
+            });
+          }
+        }
+        return {
+          assignment,
+          error: "Worker exhausted its iteration budget before returning a proposal",
+          toolResults
+        };
+      }
+    };
+  }
+});
+function normalizeArgs(args) {
+  return {
+    ...args,
+    goal: String(args.goal ?? "").trim(),
+    maxWorkers: Math.max(1, Math.min(Number(args.maxWorkers ?? 3), 5))
+  };
+}
+function buildAssignmentPrompt(args, scopes, readTools) {
+  return [
+    "You are the Dominus multi-agent assignment planner.",
+    "Create non-overlapping worker assignments for a proposal-only parallel task.",
+    'Return JSON only: {"assignments":[{"id":"worker-1","role":"...","objective":"...","ownedScopes":["..."],"allowedReadTools":["..."],"acceptanceCriteria":["..."]}]}',
+    `Goal: ${args.goal}`,
+    `Root path: ${args.rootPath ?? "(none)"}`,
+    `Task type: ${args.taskType ?? "general"}`,
+    `Constraints: ${args.constraints ?? "(none)"}`,
+    `Max workers: ${args.maxWorkers}`,
+    `Candidate scopes: ${scopes.join(", ")}`,
+    `Read tools: ${readTools.map((tool31) => tool31.name).join(", ")}`
+  ].join("\n");
+}
+function buildFallbackAssignments(args, scopes, readTools) {
+  const selectedScopes = scopes.slice(0, args.maxWorkers);
+  const allowedReadTools = readTools.map((tool31) => tool31.name);
+  const criteria = [
+    "Gather concrete evidence with read-only tools.",
+    "Propose only scoped coordinator-owned write calls.",
+    "Explain risks and verification suggestions."
+  ];
+  return selectedScopes.map((scope, index) => ({
+    id: `worker-${index + 1}`,
+    role: index === 0 ? "Inspector" : index === selectedScopes.length - 1 ? "Verifier" : "Specialist",
+    objective: `Inspect ${scope} for: ${args.goal}`,
+    ownedScopes: [scope],
+    allowedReadTools,
+    acceptanceCriteria: args.constraints ? [...criteria, args.constraints] : criteria
+  }));
+}
+function normalizeAssignments(rawAssignments, args, scopes, readTools) {
+  if (!Array.isArray(rawAssignments)) return [];
+  const allowedReadTools = readTools.map((tool31) => tool31.name);
+  return rawAssignments.slice(0, args.maxWorkers).map((assignment, index) => ({
+    id: assignment.id?.trim() || `worker-${index + 1}`,
+    role: assignment.role?.trim() || "Specialist",
+    objective: assignment.objective?.trim() || `Inspect assigned scope for: ${args.goal}`,
+    ownedScopes: Array.isArray(assignment.ownedScopes) && assignment.ownedScopes.length > 0 ? assignment.ownedScopes.map(String) : [scopes[index] ?? scopes[0] ?? args.rootPath ?? "Workspace"],
+    allowedReadTools: allowedReadTools.filter(
+      (tool31) => assignment.allowedReadTools?.length ? assignment.allowedReadTools.includes(tool31) : true
+    ),
+    acceptanceCriteria: Array.isArray(assignment.acceptanceCriteria) && assignment.acceptanceCriteria.length > 0 ? assignment.acceptanceCriteria.map(String) : ["Gather evidence and propose scoped changes only."]
+  })).filter((assignment) => assignment.ownedScopes.length > 0);
+}
+function getSerializedChildScopes(rootPath, data) {
+  const node = data && typeof data === "object" ? data : null;
+  const children = Array.isArray(node?.Children) ? node.Children : Array.isArray(node?.children) ? node.children : [];
+  return children.map((child) => child && typeof child === "object" ? child.Name : void 0).filter((name) => typeof name === "string" && name.length > 0).map((name) => `${rootPath}.${name}`);
+}
+function getExplorerChildScopes(rootPath, data) {
+  const payload = data && typeof data === "object" ? data : null;
+  const tree = Array.isArray(payload?.tree) ? payload.tree : [];
+  const root = tree[0] && typeof tree[0] === "object" ? tree[0] : null;
+  const children = Array.isArray(root?.children) ? root.children : [];
+  return children.map((child) => child && typeof child === "object" ? child.path : void 0).filter((pathValue) => typeof pathValue === "string" && pathValue.length > 0).map((pathValue) => pathValue || rootPath);
+}
+function toToolCall(name, args) {
+  return {
+    id: `multi_${nanoid()}`,
+    name,
+    arguments: args
+  };
+}
+var MultiAgentCoordinator;
+var init_coordinator = __esm({
+  "src/agent/multi-agent/coordinator.ts"() {
+    init_verifier();
+    init_json_response();
+    init_conflicts();
+    init_worker();
+    MultiAgentCoordinator = class {
+      constructor(ai, allTools) {
+        this.ai = ai;
+        this.allTools = allTools;
+      }
+      async execute(args, toolCtx, emit) {
+        const normalized = normalizeArgs(args);
+        const readTools = this.getReadOnlyTools();
+        const assignments = await this.createAssignments(normalized, toolCtx, readTools);
+        emit?.({ type: "multi_agent_start", goal: normalized.goal, workerCount: assignments.length });
+        const workerResults = await Promise.allSettled(
+          assignments.map(async (assignment) => {
+            emit?.({
+              type: "multi_agent_worker_start",
+              workerId: assignment.id,
+              role: assignment.role,
+              scopes: assignment.ownedScopes
+            });
+            const worker = new WorkerAgent(this.ai, readTools, toolCtx);
+            const result = await worker.run(normalized.goal, assignment);
+            emit?.({
+              type: "multi_agent_worker_done",
+              workerId: assignment.id,
+              summary: result.proposal?.summary ?? result.error ?? "Worker failed",
+              proposedToolCallCount: result.proposal?.proposedToolCalls.length ?? 0
+            });
+            return result;
+          })
+        );
+        const { accepted, rejected } = this.validateWorkerResults(assignments, workerResults, emit);
+        const conflictChecked = rejectConflictingAcceptedProposals(accepted);
+        for (const item of conflictChecked.rejected) {
+          emit?.({ type: "multi_agent_proposal", workerId: item.workerId, accepted: false, reason: item.reason });
+        }
+        const finalAccepted = conflictChecked.accepted;
+        const finalRejected = [...rejected, ...conflictChecked.rejected];
+        const finalToolCalls = await this.synthesizeFinalToolCalls(normalized.goal, finalAccepted);
+        const decision = {
+          accepted: finalAccepted,
+          rejected: finalRejected,
+          finalToolCalls
+        };
+        emit?.({
+          type: "multi_agent_decision",
+          acceptedCount: decision.accepted.length,
+          rejectedCount: decision.rejected.length,
+          finalToolCallCount: decision.finalToolCalls.length
+        });
+        emit?.({ type: "multi_agent_apply_start", toolCallCount: decision.finalToolCalls.length });
+        const applied = await this.applyFinalToolCalls(decision.finalToolCalls, toolCtx);
+        const verificationFailures = await this.verifyAppliedCalls(applied, toolCtx);
+        emit?.({
+          type: "multi_agent_apply_done",
+          appliedCount: applied.length,
+          verificationFailureCount: verificationFailures.length
+        });
+        return {
+          goal: normalized.goal,
+          assignments,
+          decision,
+          applied,
+          verificationFailures
+        };
+      }
+      getReadOnlyTools() {
+        return this.allTools.filter((tool31) => READ_ONLY_TOOL_NAMES.has(tool31.name));
+      }
+      getMetaTool() {
+        return {
+          name: "run_parallel_task",
+          description: "Split a broad task into coordinated read-only worker agents. Workers inspect and propose scoped changes; the coordinator validates proposals and applies safe serial writes.",
+          parameters: {
+            type: "object",
+            properties: {
+              goal: {
+                type: "string",
+                description: "The task to coordinate across sub-agents."
+              },
+              rootPath: {
+                type: "string",
+                description: "Optional root instance path to partition work under, e.g. StarterGui.HUD."
+              },
+              maxWorkers: {
+                type: "number",
+                description: "Number of workers to use. Defaults to 3, max 5.",
+                default: 3
+              },
+              constraints: {
+                type: "string",
+                description: "Extra constraints the workers and coordinator must follow."
+              },
+              taskType: {
+                type: "string",
+                description: "Optional task type hint such as ui, script, build, refactor, or general."
+              }
+            },
+            required: ["goal"]
+          },
+          execute: async () => ({
+            success: false,
+            error: "run_parallel_task is a meta-tool handled by AgentLoop or MCP, not ToolRegistry."
+          })
+        };
+      }
+      shouldAutoTrigger(userMessage) {
+        const lower = userMessage.toLowerCase();
+        return [
+          "parallel",
+          "sub-agent",
+          "subagent",
+          "agents",
+          "split this",
+          "entire ui",
+          "whole ui",
+          "organize all",
+          "organize entire",
+          "large task"
+        ].some((cue) => lower.includes(cue));
+      }
+      async createAssignments(args, toolCtx, readTools) {
+        const scopes = await this.discoverScopes(args, toolCtx);
+        const fallback = buildFallbackAssignments(args, scopes, readTools);
+        try {
+          const response = await this.ai.chat([
+            {
+              role: "system",
+              content: buildAssignmentPrompt(args, scopes, readTools)
+            }
+          ]);
+          const parsed = parseJsonResponse(response.content);
+          const assignments = normalizeAssignments(parsed?.assignments, args, scopes, readTools);
+          return assignments.length > 0 ? assignments : fallback;
+        } catch {
+          return fallback;
+        }
+      }
+      async discoverScopes(args, toolCtx) {
+        if (!args.rootPath || !toolCtx.isStudioConnected()) {
+          return args.rootPath ? [args.rootPath] : ["Workspace", "StarterGui", "ReplicatedStorage"];
+        }
+        const serializeTool = this.allTools.find((tool31) => tool31.name === "serialize_ui");
+        const looksUi = (args.taskType ?? "").toLowerCase().includes("ui") || args.rootPath.includes("Gui");
+        if (serializeTool && looksUi) {
+          const result = await serializeTool.execute({ path: args.rootPath, maxDepth: 2 }, toolCtx);
+          const childScopes = result.success ? getSerializedChildScopes(args.rootPath, result.data) : [];
+          if (childScopes.length > 0) return childScopes.slice(0, args.maxWorkers);
+        }
+        const explorerTool = this.allTools.find((tool31) => tool31.name === "get_explorer");
+        if (explorerTool) {
+          const result = await explorerTool.execute({ rootPath: args.rootPath, maxDepth: 2 }, toolCtx);
+          const childScopes = result.success ? getExplorerChildScopes(args.rootPath, result.data) : [];
+          if (childScopes.length > 0) return childScopes.slice(0, args.maxWorkers);
+        }
+        return [args.rootPath];
+      }
+      validateWorkerResults(assignments, settledResults, emit) {
+        const accepted = [];
+        const rejected = [];
+        for (let i = 0; i < settledResults.length; i++) {
+          const assignment = assignments[i];
+          const result = settledResults[i];
+          if (result.status === "rejected") {
+            const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+            rejected.push({ workerId: assignment.id, reason });
+            emit?.({ type: "multi_agent_proposal", workerId: assignment.id, accepted: false, reason });
+            continue;
+          }
+          if (!result.value.proposal) {
+            const reason = result.value.error ?? "Worker returned no proposal";
+            rejected.push({ workerId: assignment.id, reason });
+            emit?.({ type: "multi_agent_proposal", workerId: assignment.id, accepted: false, reason });
+            continue;
+          }
+          const errors = validateWorkerProposal(assignment, result.value.proposal);
+          if (errors.length > 0) {
+            const reason = errors.join("; ");
+            rejected.push({ workerId: assignment.id, proposal: result.value.proposal, reason });
+            emit?.({ type: "multi_agent_proposal", workerId: assignment.id, accepted: false, reason });
+            continue;
+          }
+          accepted.push({ workerId: assignment.id, proposal: result.value.proposal });
+          emit?.({ type: "multi_agent_proposal", workerId: assignment.id, accepted: true });
+        }
+        return { accepted, rejected };
+      }
+      async synthesizeFinalToolCalls(goal, accepted) {
+        const proposed = accepted.flatMap((item) => item.proposal.proposedToolCalls);
+        const safeCalls = proposed.filter((call) => COORDINATOR_WRITE_TOOL_NAMES.has(call.tool)).map((call) => toToolCall(call.tool, call.args));
+        if (safeCalls.length <= 1) return safeCalls;
+        try {
+          const response = await this.ai.chat([
+            {
+              role: "system",
+              content: [
+                "You are the Dominus multi-agent coordinator.",
+                "Merge accepted worker proposals into a deterministic serial write plan.",
+                'Return JSON only: {"toolCalls":[{"tool":"set_properties","args":{}}]}',
+                "Only use these tools: create_ui, set_properties, bulk_set_properties, insert_instance, move_instance.",
+                "Do not include run_code, delete_instance, edit_script, undo, or redo.",
+                `Goal: ${goal}`,
+                "Accepted proposals:",
+                JSON.stringify(accepted, null, 2)
+              ].join("\n")
+            }
+          ]);
+          const parsed = parseJsonResponse(
+            response.content
+          );
+          const merged = (parsed?.toolCalls ?? []).filter((call) => call.tool && COORDINATOR_WRITE_TOOL_NAMES.has(call.tool)).map((call) => toToolCall(call.tool, call.args ?? {}));
+          return merged.length > 0 ? merged : safeCalls;
+        } catch {
+          return safeCalls;
+        }
+      }
+      async applyFinalToolCalls(calls, toolCtx) {
+        const applied = [];
+        for (const call of calls) {
+          const targetPath = inferTargetPath({ tool: call.name, args: call.arguments });
+          if (!targetPath) {
+            applied.push({ call, result: { success: false, error: `Missing target path for ${call.name}` } });
+            continue;
+          }
+          const tool31 = this.allTools.find((candidate) => candidate.name === call.name);
+          if (!tool31) {
+            applied.push({ call, result: { success: false, error: `Unknown coordinator tool: ${call.name}` } });
+            continue;
+          }
+          applied.push({ call, result: await tool31.execute(call.arguments, toolCtx) });
+        }
+        return applied;
+      }
+      async verifyAppliedCalls(applied, toolCtx) {
+        const failures = [];
+        for (const { call, result } of applied) {
+          for (const check of inferVerifyChecks(call, result)) {
+            const verified = await verifyAction(check, toolCtx);
+            if (!verified.success) failures.push(verified);
+          }
+        }
+        return failures;
+      }
+    };
+  }
+});
+
+// src/tools/studio/read-script.ts
+var read_script_exports = {};
+__export(read_script_exports, {
+  tool: () => tool
+});
+var tool;
+var init_read_script = __esm({
+  "src/tools/studio/read-script.ts"() {
+    init_protocol();
+    tool = {
+      name: "read_script",
+      description: 'Read the source code of a script in Roblox Studio. Provide the full instance path (e.g., "ServerScriptService.GameManager").',
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: 'Full instance path of the script (e.g., "ServerScriptService.GameManager")'
+          }
+        },
+        required: ["path"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const path6 = params.path;
+        const response = await ctx.sendToStudio(CliMsg.GET_SCRIPT, { path: path6 });
+        if (!response.payload) {
+          return { success: false, error: `Script not found: ${path6}` };
+        }
+        return {
+          success: true,
+          data: {
+            path: response.payload.path,
+            className: response.payload.className,
+            source: response.payload.source,
+            lineCount: response.payload.lineCount
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/studio/edit-script.ts
+var edit_script_exports = {};
+__export(edit_script_exports, {
+  tool: () => tool2
+});
+var tool2;
+var init_edit_script = __esm({
+  "src/tools/studio/edit-script.ts"() {
+    init_protocol();
+    tool2 = {
+      name: "edit_script",
+      description: "Replace the entire source code of a script in Roblox Studio. Provide the full path and the new source code.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Full instance path of the script"
+          },
+          source: {
+            type: "string",
+            description: "The new complete source code for the script"
+          }
+        },
+        required: ["path", "source"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const path6 = params.path;
+        const source = params.source;
+        const response = await ctx.sendToStudio(CliMsg.SET_SCRIPT, { path: path6, source });
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Failed to edit script" };
+        }
+        return { success: true, data: { path: path6, linesWritten: source.split("\n").length } };
+      }
+    };
+  }
+});
+
+// src/tools/studio/run-code.ts
+var run_code_exports = {};
+__export(run_code_exports, {
+  tool: () => tool3
+});
+var tool3;
+var init_run_code = __esm({
+  "src/tools/studio/run-code.ts"() {
+    init_protocol();
+    tool3 = {
+      name: "run_code",
+      description: "Execute arbitrary Luau code in Roblox Studio and return the output. The code runs in the Studio plugin context with full API access.",
+      parameters: {
+        type: "object",
+        properties: {
           code: {
             type: "string",
             description: "Luau code to execute in Studio"
@@ -1375,10 +2494,10 @@ var init_get_descendants_properties = __esm({
           // 5 minute timeout since getting ALL descendants can take a very long time
         );
         if (params.outputFile && typeof params.outputFile === "string") {
-          const fs6 = await import('fs/promises');
-          const path5 = await import('path');
-          const outputPath = path5.resolve(process.cwd(), params.outputFile);
-          await fs6.writeFile(outputPath, JSON.stringify(response.payload, null, 2), "utf-8");
+          const fs7 = await import('fs/promises');
+          const path6 = await import('path');
+          const outputPath = path6.resolve(process.cwd(), params.outputFile);
+          await fs7.writeFile(outputPath, JSON.stringify(response.payload, null, 2), "utf-8");
           return { success: true, data: `Successfully saved descendants to ${outputPath}` };
         }
         return { success: true, data: response.payload };
@@ -1955,8 +3074,8 @@ __export(clone_instance_exports, {
   tool: () => tool19
 });
 function buildCloneCode(params) {
-  const path5 = params.path;
-  const parts = path5.split(".");
+  const path6 = params.path;
+  const parts = path6.split(".");
   let resolve = "game";
   for (const p of parts) {
     resolve += `["${p}"]`;
@@ -2097,8 +3216,8 @@ __export(build_multiple_exports, {
 });
 function generateBatchCode(parts, groupName, groupParent) {
   const lines = [];
-  function resolveParent(path5) {
-    const segs = path5.split(".");
+  function resolveParent(path6) {
+    const segs = path6.split(".");
     let r = "game";
     for (const s of segs) r += `["${s}"]`;
     return r;
@@ -2324,7 +3443,7 @@ var init_bulk_set_properties = __esm({
     init_protocol();
     tool24 = {
       name: "bulk_set_properties",
-      description: 'Set properties on multiple instances at once in a single call. Much faster than calling set_properties repeatedly. Supports two modes:\n1. Explicit paths: provide an array of {path, properties} objects\n2. By class filter: provide a root path, className filter, and properties to apply to all matches\n\nExample (explicit): [{"path": "StarterGui.HUD.Title", "properties": {"TextColor3": "#fff"}}, ...]\nExample (filter): root="StarterGui.HUD", className="TextLabel", properties={"Font": "GothamBold"}',
+      description: 'Set properties on multiple instances at once in a single call. Much faster than calling set_properties repeatedly. Supports two modes:\n1. Explicit paths: provide an array of {path, properties} objects\n2. By class filter: provide a root path, className filter, and properties to apply to all matches\n\nFilter mode also supports addChildren: insert child instances (e.g. UIStroke, UICorner) on every match. Idempotent \u2014 skips if a child of that class already exists.\n\nExample (explicit): targets=[{"path": "StarterGui.HUD.Title", "properties": {"TextColor3": "#fff"}}]\nExample (filter): root="StarterGui.HUD", className="TextLabel", properties={"Font": "RobotoBold"}\nExample (addChildren): root="StarterGui.HUD", className="TextLabel", addChildren=[{"ClassName": "UIStroke", "Color": "#000000", "Thickness": 1.5}]',
       parameters: {
         type: "object",
         properties: {
@@ -2347,6 +3466,14 @@ var init_bulk_set_properties = __esm({
           properties: {
             type: "object",
             description: "Properties to set on all matched instances (filter mode)"
+          },
+          addChildren: {
+            type: "array",
+            description: "Child instances to insert on every match (filter mode). Each item: {ClassName, Name?, ...props}. Idempotent \u2014 skips if child of that class already exists.",
+            items: {
+              type: "object",
+              description: "Child instance spec with ClassName and properties"
+            }
           }
         }
       },
@@ -2358,7 +3485,8 @@ var init_bulk_set_properties = __esm({
           targets: params.targets,
           root: params.root,
           className: params.className,
-          properties: params.properties
+          properties: params.properties,
+          addChildren: params.addChildren
         }, 1e3 * 60);
         const payload = response.payload;
         if (!payload.success) {
@@ -2442,28 +3570,546 @@ var init_find_replace_scripts = __esm({
     };
   }
 });
-
-// src/tools/memory/recall.ts
-var recall_exports = {};
-__export(recall_exports, {
-  tool: () => tool26
-});
-var tool26;
-var init_recall = __esm({
-  "src/tools/memory/recall.ts"() {
-    init_store();
-    tool26 = {
-      name: "recall_memory",
-      description: "Search your memory for previously learned facts about the current project. Use this to recall architecture decisions, patterns, known bugs, or user preferences.",
-      parameters: {
-        type: "object",
-        properties: {
-          query: {
-            type: "string",
-            description: 'What to search for in memory (e.g., "player data storage", "combat system architecture")'
-          },
-          limit: {
-            type: "number",
+async function getRobloxApiReference(name, opts = {}) {
+  const normalizedName = normalizeLookupName(name);
+  const kinds = opts.kind && opts.kind !== "any" ? [opts.kind] : Object.keys(KIND_FOLDERS);
+  for (const kind of kinds) {
+    const doc = await readReferenceYaml(normalizedName, kind, opts);
+    if (!doc) continue;
+    const reference = parseReferenceYaml(doc.content, {
+      kind,
+      sourceUrl: doc.sourceUrl
+    });
+    markDefinedOn(reference, reference.name);
+    if (opts.includeInherited && reference.kind === "class") {
+      const inherited = await collectInheritedMembers(reference, opts, /* @__PURE__ */ new Set([reference.name]));
+      reference.inheritedClasses = inherited.classes;
+      reference.inheritedMembers = inherited.members;
+    }
+    return reference;
+  }
+  throw new Error(`Roblox API reference not found for "${name}"`);
+}
+async function collectInheritedMembers(reference, opts, visited) {
+  const classes = [];
+  const members = {};
+  for (const parent of reference.inherits) {
+    if (!parent || visited.has(parent)) continue;
+    visited.add(parent);
+    const doc = await readReferenceYaml(parent, "class", opts);
+    if (!doc) continue;
+    const parentReference = parseReferenceYaml(doc.content, {
+      kind: "class",
+      sourceUrl: doc.sourceUrl
+    });
+    markDefinedOn(parentReference, parentReference.name);
+    classes.push(parentReference.name);
+    mergeMembers(members, parentReference.members);
+    const inherited = await collectInheritedMembers(parentReference, opts, visited);
+    classes.push(...inherited.classes);
+    mergeMembers(members, inherited.members);
+  }
+  return { classes, members };
+}
+function markDefinedOn(reference, className) {
+  for (const section of Object.values(reference.members)) {
+    for (const member of section) {
+      member.definedOn = className;
+    }
+  }
+}
+function mergeMembers(target, source) {
+  for (const [section, members] of Object.entries(source)) {
+    target[section] ??= [];
+    target[section].push(...members);
+  }
+}
+async function searchRobloxApi(query, opts = {}) {
+  const limit = Math.max(1, Math.min(opts.limit ?? 10, 50));
+  const normalizedQuery = normalizeSearchText(query);
+  const kinds = opts.kind && opts.kind !== "any" ? [opts.kind] : Object.keys(KIND_FOLDERS);
+  const entries = await listReferenceEntries(opts);
+  return entries.filter((entry) => kinds.includes(entry.kind)).map((entry) => ({
+    ...entry,
+    score: scoreSearchResult(normalizedQuery, entry.name, entry.kind)
+  })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.name.localeCompare(b.name)).slice(0, limit);
+}
+function parseReferenceYaml(raw, opts = {}) {
+  const kind = opts.kind ?? normalizeKind(readTopScalar(raw, "type")) ?? "class";
+  const members = {};
+  for (const section of MEMBER_SECTIONS) {
+    const parsed = parseMemberSection(raw, section);
+    if (parsed.length > 0) {
+      members[section] = parsed;
+    }
+  }
+  return {
+    name: readTopScalar(raw, "name") || "Unknown",
+    kind,
+    summary: cleanDocText(readTopScalar(raw, "summary")),
+    description: cleanDocText(readTopScalar(raw, "description")),
+    inherits: readTopList(raw, "inherits"),
+    tags: readTopList(raw, "tags"),
+    deprecationMessage: cleanDocText(readTopScalar(raw, "deprecation_message")),
+    sourceUrl: opts.sourceUrl ?? "",
+    members
+  };
+}
+function normalizeKind(value) {
+  if (value === "class" || value === "datatype" || value === "enum" || value === "global" || value === "library") {
+    return value;
+  }
+  return void 0;
+}
+async function readReferenceYaml(name, kind, opts) {
+  const localRoot = resolveDocsRoot(opts.docsRoot);
+  const folder = KIND_FOLDERS[kind];
+  const fileName = `${name}.yaml`;
+  if (localRoot) {
+    const localPath = path5.join(localRoot, folder, fileName);
+    if (fs6.existsSync(localPath)) {
+      return {
+        content: fs6.readFileSync(localPath, "utf-8"),
+        sourceUrl: toCreatorDocsUrl(kind, name)
+      };
+    }
+  }
+  const sourceUrl = `${GITHUB_RAW_BASE}/${folder}/${encodeURIComponent(fileName)}`;
+  try {
+    return {
+      content: await fetchText(sourceUrl),
+      sourceUrl: toCreatorDocsUrl(kind, name)
+    };
+  } catch {
+    return null;
+  }
+}
+async function listReferenceEntries(opts) {
+  const localRoot = resolveDocsRoot(opts.docsRoot);
+  if (localRoot) {
+    const entries = [];
+    for (const [kind, folder] of Object.entries(KIND_FOLDERS)) {
+      const dir = path5.join(localRoot, folder);
+      if (!fs6.existsSync(dir)) continue;
+      for (const file of fs6.readdirSync(dir)) {
+        if (!file.endsWith(".yaml")) continue;
+        const name = path5.basename(file, ".yaml");
+        entries.push({ name, kind, score: 0, sourceUrl: toCreatorDocsUrl(kind, name) });
+      }
+    }
+    return entries;
+  }
+  const tree = await getRemoteTree();
+  const prefix = "content/en-us/reference/engine/";
+  return tree.filter((entry) => entry.type === "blob").map((entry) => entry.path).filter((entryPath) => entryPath.startsWith(prefix) && entryPath.endsWith(".yaml")).flatMap((entryPath) => {
+    const rest = entryPath.slice(prefix.length);
+    const [folder, file] = rest.split("/");
+    const kind = folderToKind(folder);
+    if (!kind || !file) return [];
+    const name = path5.basename(file, ".yaml");
+    return [{ name, kind, score: 0, sourceUrl: toCreatorDocsUrl(kind, name) }];
+  });
+}
+async function getRemoteTree() {
+  if (remoteTreeCache) return remoteTreeCache;
+  const payload = JSON.parse(await fetchText(GITHUB_TREE_URL));
+  remoteTreeCache = payload.tree ?? [];
+  return remoteTreeCache;
+}
+function folderToKind(folder) {
+  for (const [kind, value] of Object.entries(KIND_FOLDERS)) {
+    if (value === folder) return kind;
+  }
+  return void 0;
+}
+function resolveDocsRoot(explicitRoot) {
+  const candidates = [
+    explicitRoot,
+    process.env.ROBLOX_CREATOR_DOCS_PATH,
+    path5.join(process.cwd(), ".tmp", "creator-docs")
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    const normalized = normalizeDocsRoot(candidate);
+    if (normalized && fs6.existsSync(normalized)) return normalized;
+  }
+  return null;
+}
+function normalizeDocsRoot(root) {
+  const engineRoot = path5.join(root, "content", "en-us", "reference", "engine");
+  if (fs6.existsSync(engineRoot)) return engineRoot;
+  const directClasses = path5.join(root, "classes");
+  if (fs6.existsSync(directClasses)) return root;
+  return null;
+}
+function normalizeLookupName(name) {
+  const trimmed = name.trim();
+  const ownerName = trimmed.split(":")[0];
+  const lastToken = ownerName.split(".").pop() ?? ownerName;
+  return lastToken.replace(/[^A-Za-z0-9_]/g, "");
+}
+function normalizeSearchText(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9_]+/g, "");
+}
+function scoreSearchResult(query, name, kind) {
+  if (!query) return 1;
+  const normalizedName = normalizeSearchText(name);
+  if (normalizedName === query) return 100;
+  if (normalizedName.startsWith(query)) return 75;
+  if (normalizedName.includes(query)) return 50;
+  const kindScore = kind.includes(query) ? 10 : 0;
+  return kindScore;
+}
+function toCreatorDocsUrl(kind, name) {
+  return `https://create.roblox.com/docs/reference/engine/${KIND_FOLDERS[kind]}/${name}`;
+}
+async function fetchText(url) {
+  const response = await fetch(url, {
+    headers: { "User-Agent": "Dominus Roblox API docs lookup" }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  return response.text();
+}
+function readTopScalar(raw, key) {
+  const lines = raw.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(new RegExp(`^${escapeRegExp(key)}:\\s*(.*)$`));
+    if (!match) continue;
+    return readYamlValue(lines, i, 0, match[1]);
+  }
+  return "";
+}
+function readTopList(raw, key) {
+  const lines = raw.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(new RegExp(`^${escapeRegExp(key)}:\\s*(.*)$`));
+    if (!match) continue;
+    const inline = match[1].trim();
+    if (inline === "[]" || inline === "") {
+      if (inline === "[]") return [];
+      return readIndentedList(lines, i + 1, 2);
+    }
+    return [unquote(inline)];
+  }
+  return [];
+}
+function parseMemberSection(raw, section) {
+  const sectionLines = extractTopSection(raw, section);
+  if (sectionLines.length === 0) return [];
+  const items = splitMemberItems(sectionLines);
+  return items.map((item) => parseMemberItem(item, section)).filter((item) => Boolean(item));
+}
+function extractTopSection(raw, section) {
+  const lines = raw.split(/\r?\n/);
+  const start = lines.findIndex((line) => line === `${section}:`);
+  if (start === -1) return [];
+  const result = [];
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^[A-Za-z_][A-Za-z0-9_]*:/.test(lines[i])) break;
+    result.push(lines[i]);
+  }
+  return result;
+}
+function splitMemberItems(lines) {
+  const items = [];
+  let current = [];
+  for (const line of lines) {
+    if (/^  - /.test(line)) {
+      if (current.length > 0) items.push(current);
+      current = [line];
+      continue;
+    }
+    if (current.length > 0) current.push(line);
+  }
+  if (current.length > 0) items.push(current);
+  return items;
+}
+function parseMemberItem(lines, section) {
+  const name = readMemberScalar(lines, "name");
+  if (!name) return null;
+  const member = {
+    name,
+    memberType: section,
+    type: readMemberScalar(lines, "type") || readMemberScalar(lines, "return_type"),
+    summary: cleanDocText(readMemberScalar(lines, "summary")),
+    description: cleanDocText(readMemberScalar(lines, "description")),
+    parameters: readNestedObjects(lines, "parameters"),
+    returns: readNestedObjects(lines, "returns"),
+    tags: readMemberList(lines, "tags"),
+    security: readSecurity(lines),
+    threadSafety: readMemberScalar(lines, "thread_safety"),
+    category: readMemberScalar(lines, "category"),
+    deprecationMessage: cleanDocText(readMemberScalar(lines, "deprecation_message"))
+  };
+  const value = Number(readMemberScalar(lines, "value"));
+  if (Number.isFinite(value)) member.value = value;
+  return member;
+}
+function readMemberScalar(lines, key) {
+  for (let i = 0; i < lines.length; i++) {
+    const firstLinePattern = new RegExp(`^  - ${escapeRegExp(key)}:\\s*(.*)$`);
+    const fieldPattern = new RegExp(`^    ${escapeRegExp(key)}:\\s*(.*)$`);
+    const firstLineMatch = lines[i].match(firstLinePattern);
+    const fieldMatch = lines[i].match(fieldPattern);
+    const match = firstLineMatch ?? fieldMatch;
+    if (!match) continue;
+    return readYamlValue(lines, i, firstLineMatch ? 2 : 4, match[1]);
+  }
+  return "";
+}
+function readMemberList(lines, key) {
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(new RegExp(`^    ${escapeRegExp(key)}:\\s*(.*)$`));
+    if (!match) continue;
+    const inline = match[1].trim();
+    if (inline === "[]") return [];
+    if (inline) return [unquote(inline)];
+    return readIndentedList(lines, i + 1, 6);
+  }
+  return [];
+}
+function readNestedObjects(lines, key) {
+  const start = lines.findIndex((line) => line === `    ${key}:`);
+  if (start === -1) return [];
+  const nested = [];
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^    [A-Za-z_][A-Za-z0-9_]*:/.test(lines[i])) break;
+    nested.push(lines[i]);
+  }
+  const items = [];
+  let current = [];
+  for (const line of nested) {
+    if (/^      - /.test(line)) {
+      if (current.length > 0) items.push(current);
+      current = [line];
+      continue;
+    }
+    if (current.length > 0) current.push(line);
+  }
+  if (current.length > 0) items.push(current);
+  return items.map((item) => ({
+    name: readNestedScalar(item, "name"),
+    type: readNestedScalar(item, "type"),
+    summary: cleanDocText(readNestedScalar(item, "summary")),
+    default: readNestedScalar(item, "default")
+  }));
+}
+function readNestedScalar(lines, key) {
+  for (let i = 0; i < lines.length; i++) {
+    const firstLinePattern = new RegExp(`^      - ${escapeRegExp(key)}:\\s*(.*)$`);
+    const fieldPattern = new RegExp(`^        ${escapeRegExp(key)}:\\s*(.*)$`);
+    const firstLineMatch = lines[i].match(firstLinePattern);
+    const fieldMatch = lines[i].match(fieldPattern);
+    const match = firstLineMatch ?? fieldMatch;
+    if (!match) continue;
+    return readYamlValue(lines, i, firstLineMatch ? 6 : 8, match[1]);
+  }
+  return "";
+}
+function readSecurity(lines) {
+  const start = lines.findIndex((line) => line === "    security:");
+  if (start === -1) return void 0;
+  return {
+    read: readIndentedScalar(lines, start + 1, "read", 6),
+    write: readIndentedScalar(lines, start + 1, "write", 6)
+  };
+}
+function readIndentedScalar(lines, start, key, indent) {
+  const pattern = new RegExp(`^\\s{${indent}}${escapeRegExp(key)}:\\s*(.*)$`);
+  for (let i = start; i < lines.length; i++) {
+    if (indentOf(lines[i]) < indent) break;
+    const match = lines[i].match(pattern);
+    if (match) return unquote(match[1].trim());
+  }
+  return "";
+}
+function readYamlValue(lines, index, indent, rawValue) {
+  const value = rawValue.trim();
+  if (value === "|-" || value === "|") {
+    return readBlock(lines, index + 1, indent + 2);
+  }
+  if (value === "''" || value === '""') return "";
+  return unquote(value);
+}
+function readBlock(lines, start, minIndent) {
+  const block = [];
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() && indentOf(line) < minIndent) break;
+    block.push(line.slice(Math.min(minIndent, line.length)));
+  }
+  return block.join("\n").trim();
+}
+function readIndentedList(lines, start, indent) {
+  const pattern = new RegExp(`^\\s{${indent}}-\\s*(.*)$`);
+  const values = [];
+  for (let i = start; i < lines.length; i++) {
+    if (lines[i].trim() && indentOf(lines[i]) < indent) break;
+    const match = lines[i].match(pattern);
+    if (match) values.push(unquote(match[1].trim()));
+  }
+  return values;
+}
+function cleanDocText(value) {
+  return value.replace(/\r/g, "").replace(/[ \t]+\n/g, "\n").trim();
+}
+function indentOf(line) {
+  return line.match(/^ */)?.[0].length ?? 0;
+}
+function unquote(value) {
+  if (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var GITHUB_RAW_BASE, GITHUB_TREE_URL, KIND_FOLDERS, MEMBER_SECTIONS, remoteTreeCache;
+var init_roblox_api = __esm({
+  "src/docs/roblox-api.ts"() {
+    GITHUB_RAW_BASE = "https://raw.githubusercontent.com/Roblox/creator-docs/main/content/en-us/reference/engine";
+    GITHUB_TREE_URL = "https://api.github.com/repos/Roblox/creator-docs/git/trees/main?recursive=1";
+    KIND_FOLDERS = {
+      class: "classes",
+      datatype: "datatypes",
+      enum: "enums",
+      global: "globals",
+      library: "libraries"
+    };
+    MEMBER_SECTIONS = [
+      "properties",
+      "methods",
+      "events",
+      "callbacks",
+      "constructors",
+      "functions",
+      "items",
+      "constants",
+      "math_operations"
+    ];
+    remoteTreeCache = null;
+  }
+});
+
+// src/tools/docs/search-roblox-api.ts
+var search_roblox_api_exports = {};
+__export(search_roblox_api_exports, {
+  tool: () => tool26
+});
+var tool26;
+var init_search_roblox_api = __esm({
+  "src/tools/docs/search-roblox-api.ts"() {
+    init_roblox_api();
+    tool26 = {
+      name: "search_roblox_api",
+      description: "Search Roblox Creator Docs engine API reference names. Use this when you are unsure of an exact class, enum, datatype, global, or library name.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: 'Name fragment to search, e.g. "Text", "Run", "UDim", "FrameStyle"'
+          },
+          kind: {
+            type: "string",
+            description: "Optional reference kind filter.",
+            enum: ["any", "class", "datatype", "enum", "global", "library"],
+            default: "any"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum results to return (default: 10, max: 50)",
+            default: 10
+          }
+        },
+        required: ["query"]
+      },
+      async execute(params) {
+        try {
+          const results = await searchRobloxApi(String(params.query ?? ""), {
+            kind: params.kind ?? "any",
+            limit: params.limit ?? 10
+          });
+          return { success: true, data: { results } };
+        } catch (err) {
+          return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+    };
+  }
+});
+
+// src/tools/docs/get-roblox-api-reference.ts
+var get_roblox_api_reference_exports = {};
+__export(get_roblox_api_reference_exports, {
+  tool: () => tool27
+});
+var tool27;
+var init_get_roblox_api_reference = __esm({
+  "src/tools/docs/get-roblox-api-reference.ts"() {
+    init_roblox_api();
+    tool27 = {
+      name: "get_roblox_api_reference",
+      description: "Look up Roblox Creator Docs engine API reference for a class, datatype, enum, global, or library. Works without Studio connected and includes summaries, descriptions, tags, members, parameters, returns, security, and thread safety.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: 'API reference name, e.g. "Frame", "RunService", "UDim2", "FrameStyle", "task"'
+          },
+          kind: {
+            type: "string",
+            description: 'Optional reference kind. Use "any" to search all reference kinds.',
+            enum: ["any", "class", "datatype", "enum", "global", "library"],
+            default: "any"
+          },
+          includeInherited: {
+            type: "boolean",
+            description: "For classes, include members from inherited base classes (default: true).",
+            default: true
+          }
+        },
+        required: ["name"]
+      },
+      async execute(params) {
+        try {
+          const reference = await getRobloxApiReference(String(params.name ?? ""), {
+            kind: params.kind ?? "any",
+            includeInherited: params.includeInherited !== false
+          });
+          return { success: true, data: reference };
+        } catch (err) {
+          return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+    };
+  }
+});
+
+// src/tools/memory/recall.ts
+var recall_exports = {};
+__export(recall_exports, {
+  tool: () => tool28
+});
+var tool28;
+var init_recall = __esm({
+  "src/tools/memory/recall.ts"() {
+    init_store();
+    tool28 = {
+      name: "recall_memory",
+      description: "Search your memory for previously learned facts about the current project. Use this to recall architecture decisions, patterns, known bugs, or user preferences.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: 'What to search for in memory (e.g., "player data storage", "combat system architecture")'
+          },
+          limit: {
+            type: "number",
             description: "Max number of facts to return (default: 10)",
             default: 10
           }
@@ -2491,13 +4137,13 @@ var init_recall = __esm({
 // src/tools/memory/remember.ts
 var remember_exports = {};
 __export(remember_exports, {
-  tool: () => tool27
+  tool: () => tool29
 });
-var tool27;
+var tool29;
 var init_remember = __esm({
   "src/tools/memory/remember.ts"() {
     init_store();
-    tool27 = {
+    tool29 = {
       name: "remember",
       description: "Store a fact about the current project in persistent memory. Use this to remember architecture decisions, patterns, bugs found, or user preferences so you can recall them in future sessions.",
       parameters: {
@@ -2537,12 +4183,12 @@ var init_remember = __esm({
 // src/tools/cloud/upload-asset.ts
 var upload_asset_exports = {};
 __export(upload_asset_exports, {
-  tool: () => tool28
+  tool: () => tool30
 });
-var tool28;
+var tool30;
 var init_upload_asset = __esm({
   "src/tools/cloud/upload-asset.ts"() {
-    tool28 = {
+    tool30 = {
       name: "upload_asset",
       description: "Upload a local file (image, model, audio) to Roblox via the Open Cloud API. Requires an Open Cloud API key configured in dominus.",
       parameters: {
@@ -2580,11 +4226,11 @@ var init_upload_asset = __esm({
         const assetType = params.assetType;
         const name = params.name;
         const description = params.description ?? "";
-        if (!fs5.existsSync(filePath)) {
+        if (!fs6.existsSync(filePath)) {
           return { success: false, error: `File not found: ${filePath}` };
         }
-        const fileBuffer = fs5.readFileSync(filePath);
-        const fileName = path4.basename(filePath);
+        const fileBuffer = fs6.readFileSync(filePath);
+        const fileName = path5.basename(filePath);
         const typeMapping = {
           Image: "Decal",
           Audio: "Audio",
@@ -2689,6 +4335,99 @@ var init_undo_redo = __esm({
   }
 });
 
+// src/tools/registry.ts
+function createDefaultRegistry() {
+  const registry = new ToolRegistry();
+  const toolModules = [
+    Promise.resolve().then(() => (init_read_script(), read_script_exports)),
+    Promise.resolve().then(() => (init_edit_script(), edit_script_exports)),
+    Promise.resolve().then(() => (init_run_code(), run_code_exports)),
+    Promise.resolve().then(() => (init_get_explorer(), get_explorer_exports)),
+    Promise.resolve().then(() => (init_get_properties(), get_properties_exports)),
+    Promise.resolve().then(() => (init_get_descendants_properties(), get_descendants_properties_exports)),
+    Promise.resolve().then(() => (init_set_properties(), set_properties_exports)),
+    Promise.resolve().then(() => (init_insert_instance(), insert_instance_exports)),
+    Promise.resolve().then(() => (init_delete_instance(), delete_instance_exports)),
+    Promise.resolve().then(() => (init_get_output(), get_output_exports)),
+    Promise.resolve().then(() => (init_get_selection(), get_selection_exports)),
+    Promise.resolve().then(() => (init_search_scripts(), search_scripts_exports)),
+    Promise.resolve().then(() => (init_run_tests(), run_tests_exports)),
+    Promise.resolve().then(() => (init_get_class_info(), get_class_info_exports)),
+    Promise.resolve().then(() => (init_create_ui(), create_ui_exports)),
+    Promise.resolve().then(() => (init_execute_run_test(), execute_run_test_exports)),
+    Promise.resolve().then(() => (init_execute_play_test(), execute_play_test_exports)),
+    Promise.resolve().then(() => (init_create_part(), create_part_exports)),
+    Promise.resolve().then(() => (init_clone_instance(), clone_instance_exports)),
+    Promise.resolve().then(() => (init_group_instances(), group_instances_exports)),
+    Promise.resolve().then(() => (init_build_multiple(), build_multiple_exports)),
+    Promise.resolve().then(() => (init_serialize_ui(), serialize_ui_exports)),
+    Promise.resolve().then(() => (init_move_instance(), move_instance_exports)),
+    Promise.resolve().then(() => (init_bulk_set_properties(), bulk_set_properties_exports)),
+    Promise.resolve().then(() => (init_find_replace_scripts(), find_replace_scripts_exports)),
+    Promise.resolve().then(() => (init_search_roblox_api(), search_roblox_api_exports)),
+    Promise.resolve().then(() => (init_get_roblox_api_reference(), get_roblox_api_reference_exports)),
+    Promise.resolve().then(() => (init_recall(), recall_exports)),
+    Promise.resolve().then(() => (init_remember(), remember_exports)),
+    Promise.resolve().then(() => (init_upload_asset(), upload_asset_exports))
+  ];
+  registry.addReadyTask(Promise.all(
+    toolModules.map(async (mod) => {
+      const m = await mod;
+      if (m.tool) registry.register(m.tool);
+    })
+  ));
+  registry.addReadyTask(Promise.resolve().then(() => (init_undo_redo(), undo_redo_exports)).then((m) => {
+    registry.register(m.undoTool);
+    registry.register(m.redoTool);
+  }));
+  return registry;
+}
+var ToolRegistry;
+var init_registry = __esm({
+  "src/tools/registry.ts"() {
+    ToolRegistry = class {
+      tools = /* @__PURE__ */ new Map();
+      readyTasks = [];
+      register(tool31) {
+        if (this.tools.has(tool31.name)) {
+          throw new Error(`Tool already registered: ${tool31.name}`);
+        }
+        this.tools.set(tool31.name, tool31);
+      }
+      get(name) {
+        return this.tools.get(name);
+      }
+      getAll() {
+        return Array.from(this.tools.values());
+      }
+      getSchemas() {
+        return this.getAll();
+      }
+      async execute(call, ctx) {
+        const tool31 = this.tools.get(call.name);
+        if (!tool31) {
+          return { success: false, error: `Unknown tool: ${call.name}` };
+        }
+        try {
+          return await tool31.execute(call.arguments, ctx);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { success: false, error: message };
+        }
+      }
+      listNames() {
+        return Array.from(this.tools.keys());
+      }
+      addReadyTask(task) {
+        this.readyTasks.push(task);
+      }
+      async ready() {
+        await Promise.all(this.readyTasks);
+      }
+    };
+  }
+});
+
 // src/mcp/server.ts
 var server_exports = {};
 __export(server_exports, {
@@ -2709,7 +4448,7 @@ async function startMcpServer() {
   }
   const mcp = new McpServer({
     name: "dominus",
-    version: "0.6.0"
+    version: "2.0.0"
   }, {
     instructions: INTERNAL_MEMORY
   });
@@ -2821,9 +4560,9 @@ ${"	".repeat(_depth)}}`;
     "read_script",
     "Read the source code of a script in Roblox Studio",
     { path: z.string().describe('Full instance path, e.g. "ServerScriptService.GameManager"') },
-    async ({ path: path5 }) => {
+    async ({ path: path6 }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.GET_SCRIPT, { path: path5 });
+      const res = await bridge.sendRequest(CliMsg.GET_SCRIPT, { path: path6 });
       return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
     }
   );
@@ -2834,9 +4573,9 @@ ${"	".repeat(_depth)}}`;
       path: z.string().describe("Full instance path"),
       source: z.string().describe("New complete source code")
     },
-    async ({ path: path5, source }) => {
+    async ({ path: path6, source }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.SET_SCRIPT, { path: path5, source });
+      const res = await bridge.sendRequest(CliMsg.SET_SCRIPT, { path: path6, source });
       return { content: [{ type: "text", text: JSON.stringify(res.payload) }] };
     }
   );
@@ -2873,9 +4612,9 @@ ${"	".repeat(_depth)}}`;
       path: z.string().describe('Full instance path (e.g. "Workspace.Part", "StarterGui.MyUI.Frame")'),
       compact: z.boolean().optional().default(true).describe("Strip read-only, nil, deprecated, and default-valued properties (default true). Set false for full dump.")
     },
-    async ({ path: path5, compact }) => {
+    async ({ path: path6, compact }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.GET_PROPERTIES, { path: path5, compact });
+      const res = await bridge.sendRequest(CliMsg.GET_PROPERTIES, { path: path6, compact });
       return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
     }
   );
@@ -2887,9 +4626,9 @@ ${"	".repeat(_depth)}}`;
       compact: z.boolean().optional().default(true).describe("Strip noisy/default properties (default true). Set false for full dump."),
       outputFile: z.string().optional().describe("Optional file path to write to prevent limit errors/timeouts")
     },
-    async ({ path: path5, compact, outputFile }) => {
+    async ({ path: path6, compact, outputFile }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.GET_DESCENDANTS_PROPERTIES, { path: path5, compact, outputFile }, 1e3 * 60 * 5);
+      const res = await bridge.sendRequest(CliMsg.GET_DESCENDANTS_PROPERTIES, { path: path6, compact, outputFile }, 1e3 * 60 * 5);
       return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
     }
   );
@@ -2900,9 +4639,9 @@ ${"	".repeat(_depth)}}`;
       path: z.string().describe("Full instance path"),
       properties: z.record(z.unknown()).describe("Key-value pairs of properties to set")
     },
-    async ({ path: path5, properties }) => {
+    async ({ path: path6, properties }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.SET_PROPERTIES, { path: path5, properties });
+      const res = await bridge.sendRequest(CliMsg.SET_PROPERTIES, { path: path6, properties });
       return { content: [{ type: "text", text: JSON.stringify(res.payload) }] };
     }
   );
@@ -2930,9 +4669,9 @@ ${"	".repeat(_depth)}}`;
     "delete_instance",
     "Delete an instance from the Roblox Studio DataModel",
     { path: z.string().describe("Full instance path to delete") },
-    async ({ path: path5 }) => {
+    async ({ path: path6 }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.DELETE_INSTANCE, { path: path5 });
+      const res = await bridge.sendRequest(CliMsg.DELETE_INSTANCE, { path: path6 });
       return { content: [{ type: "text", text: JSON.stringify(res.payload) }] };
     }
   );
@@ -2985,6 +4724,61 @@ ${"	".repeat(_depth)}}`;
       return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
     }
   );
+  mcp.tool(
+    "search_roblox_api",
+    "Search Roblox Creator Docs engine API reference names. Use when you are unsure of the exact class, enum, datatype, global, or library name. Works without Studio connected.",
+    {
+      query: z.string().describe('Name fragment to search, e.g. "Text", "Run", "UDim", "FrameStyle"'),
+      kind: z.enum(["any", "class", "datatype", "enum", "global", "library"]).optional().default("any"),
+      limit: z.number().optional().default(10).describe("Maximum results to return")
+    },
+    async ({ query, kind, limit }) => {
+      const results = await searchRobloxApi(query, { kind, limit });
+      return { content: [{ type: "text", text: JSON.stringify({ results }, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "get_roblox_api_reference",
+    "Look up Roblox Creator Docs engine API reference for a class, datatype, enum, global, or library. Includes summaries, descriptions, members, parameters, returns, security, and thread safety. Works without Studio connected.",
+    {
+      name: z.string().describe('API reference name, e.g. "Frame", "RunService", "UDim2", "FrameStyle", "task"'),
+      kind: z.enum(["any", "class", "datatype", "enum", "global", "library"]).optional().default("any"),
+      includeInherited: z.boolean().optional().default(true).describe("For classes, include members from inherited base classes")
+    },
+    async ({ name, kind, includeInherited }) => {
+      const reference = await getRobloxApiReference(name, { kind, includeInherited });
+      return { content: [{ type: "text", text: JSON.stringify(reference, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "run_parallel_task",
+    "Split a broad task into coordinated read-only worker agents. Workers inspect and propose scoped changes; the coordinator validates proposals and applies safe serial writes.",
+    {
+      goal: z.string().describe("The task to coordinate across sub-agents"),
+      rootPath: z.string().optional().describe("Optional root instance path to partition work under, e.g. StarterGui.HUD"),
+      maxWorkers: z.number().optional().default(3).describe("Number of workers to use, max 5"),
+      constraints: z.string().optional().describe("Extra constraints workers and coordinator must follow"),
+      taskType: z.string().optional().describe("Optional task type hint such as ui, script, build, refactor, or general")
+    },
+    async ({ goal, rootPath, maxWorkers, constraints, taskType }) => {
+      const registry = createDefaultRegistry();
+      await registry.ready();
+      const ai = new AIProvider(loadConfig());
+      const coordinator = new MultiAgentCoordinator(ai, registry.getAll());
+      const events = [];
+      const result = await coordinator.execute(
+        { goal, rootPath, maxWorkers, constraints, taskType },
+        createMcpToolContext(),
+        (event) => events.push(event)
+      );
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ ...result, events }, null, 2)
+        }]
+      };
+    }
+  );
   mcp.tool(
     "create_ui",
     'Create an entire UI tree in one call. Pass a declarative JSON tree \u2014 ClassName, Name, properties, Children. All types auto-coerced in Luau (UDim2, Color3, Font, enums). 10x faster than run_code. UDim2: [xScale, xOffset, yScale, yOffset]. Color3: "#hex" or "rgb(r,g,b)". Font: "GothamBold". Enums: string names.',
@@ -3200,11 +4994,11 @@ ${"	".repeat(_depth)}}`;
       path: z.string().describe('Instance path to serialize (e.g. "StarterGui.MyScreenGui")'),
       maxDepth: z.number().optional().default(50).describe("Maximum tree depth (default 50)")
     },
-    async ({ path: path5, maxDepth }) => {
+    async ({ path: path6, maxDepth }) => {
       assertConnected();
       const res = await bridge.sendRequest(
         CliMsg.SERIALIZE_UI,
-        { path: path5, maxDepth },
+        { path: path6, maxDepth },
         1e3 * 60 * 2
       );
       if (!res.payload.success) {
@@ -3249,16 +5043,16 @@ ${"	".repeat(_depth)}}`;
       path: z.string().describe('Full instance path (e.g. "Workspace.MyModel")'),
       childDepth: z.number().optional().default(2).describe("How deep to show the children tree (default 2)")
     },
-    async ({ path: path5, childDepth }) => {
+    async ({ path: path6, childDepth }) => {
       assertConnected();
       const [propRes, treeRes] = await Promise.all([
         bridge.sendRequest(
           CliMsg.GET_PROPERTIES,
-          { path: path5, compact: true }
+          { path: path6, compact: true }
         ),
         bridge.sendRequest(
           CliMsg.GET_EXPLORER,
-          { rootPath: path5, maxDepth: childDepth ?? 2 }
+          { rootPath: path6, maxDepth: childDepth ?? 2 }
         )
       ]);
       return {
@@ -3280,11 +5074,11 @@ ${"	".repeat(_depth)}}`;
       framework: z.enum(["roact", "react"]).optional().default("react").describe('Target framework: "roact" (legacy) or "react" (react-lua, default)'),
       componentName: z.string().optional().describe("Name for the generated component (defaults to instance Name)")
     },
-    async ({ path: path5, framework, componentName }) => {
+    async ({ path: path6, framework, componentName }) => {
       assertConnected();
       const res = await bridge.sendRequest(
         CliMsg.SERIALIZE_UI,
-        { path: path5, maxDepth: 50 },
+        { path: path6, maxDepth: 50 },
         1e3 * 60 * 2
       );
       if (!res.payload.success || !res.payload.tree) {
@@ -3335,7 +5129,16 @@ ${"	".repeat(_depth)}}`;
           }]
         };
       }
-      bridge.setActivePlaceId(placeId);
+      try {
+        bridge.setActivePlaceId(placeId);
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: err instanceof Error ? err.message : String(err)
+          }]
+        };
+      }
       if (placeId === 0) {
         return { content: [{ type: "text", text: "Active place reset to auto-select." }] };
       }
@@ -3401,11 +5204,50 @@ ${"	".repeat(_depth)}}`;
 }
 function assertConnected() {
   if (!bridge.isConnected()) {
+    const connections = bridge.listConnections();
+    const activePlaceId = bridge.getActivePlaceId();
+    if (connections.length > 1 && activePlaceId === 0) {
+      const available = connections.map((c) => `${c.placeName ?? "Unknown"} (${c.placeId})`).join(", ");
+      throw new Error(`Multiple Roblox Studio instances are connected: ${available}. Use list_connections and set_active_place before running Studio tools.`);
+    }
+    if (connections.length > 0 && activePlaceId !== 0) {
+      throw new Error(`Active Roblox Studio place ${activePlaceId} is not connected. Use list_connections and set_active_place to choose a connected Studio instance.`);
+    }
     throw new Error(
       "Roblox Studio is not connected. Open Studio and click the Dominus plugin Connect button."
     );
   }
 }
+function createMcpToolContext() {
+  return {
+    sendToStudio: (type, payload, timeoutMs) => {
+      return bridge.sendRequest(type, payload, timeoutMs);
+    },
+    isStudioConnected: () => bridge.isConnected(),
+    memory: {
+      recall: (query, projectId, limit) => {
+        const facts = recallFacts(projectId || "current", query, limit);
+        return facts.map((fact) => fact.content);
+      },
+      learn: (projectId, facts) => {
+        const now = Date.now();
+        for (const fact of facts) {
+          storeFact({
+            projectId: projectId || "current",
+            content: fact.content,
+            category: fact.category,
+            source: "mcp",
+            relevance: 1,
+            createdAt: now,
+            accessedAt: now
+          });
+        }
+      },
+      getScriptIndex: (projectId) => getScriptIndex(projectId || "current")
+    },
+    config: createConfigAccess()
+  };
+}
 var bridge;
 var init_server = __esm({
   "src/mcp/server.ts"() {
@@ -3415,6 +5257,10 @@ var init_server = __esm({
     init_store();
     init_config();
     init_internal_memory();
+    init_roblox_api();
+    init_provider();
+    init_coordinator();
+    init_registry();
   }
 });
 var CROWN_ART = `    \u25C6       \u25C6       \u25C6
@@ -4478,144 +6324,8 @@ var App = ({ server, agent: initialAgent, version }) => {
 init_ws_server();
 init_ws_client();
 
-// src/ai/provider.ts
-init_config();
-var AIProvider = class {
-  client;
-  model;
-  providerName;
-  constructor(config) {
-    if (!config.apiKey) {
-      throw new Error("API key not configured. Run: dominus config set apiKey <your-key>");
-    }
-    const { baseUrl, model } = resolveProviderSettings(config);
-    this.providerName = PROVIDERS[config.provider]?.name ?? config.provider;
-    this.client = new OpenAI({
-      apiKey: config.apiKey,
-      baseURL: baseUrl
-    });
-    this.model = model;
-  }
-  setModel(model) {
-    this.model = model;
-  }
-  getModel() {
-    return this.model;
-  }
-  getProviderName() {
-    return this.providerName;
-  }
-  async listModels() {
-    try {
-      const list = await this.client.models.list();
-      const models = [];
-      for await (const m of list) {
-        models.push({ id: m.id, owned_by: m.owned_by });
-      }
-      models.sort((a, b) => a.id.localeCompare(b.id));
-      return models;
-    } catch {
-      return [];
-    }
-  }
-  async chat(messages, tools) {
-    const openAITools = tools?.map(toolToOpenAI);
-    const response = await this.client.chat.completions.create({
-      model: this.model,
-      messages,
-      tools: openAITools?.length ? openAITools : void 0,
-      temperature: 0.3
-    });
-    const choice = response.choices[0];
-    if (!choice) throw new Error("No response from AI");
-    const toolCalls = (choice.message.tool_calls ?? []).map((tc) => ({
-      id: tc.id,
-      name: tc.function.name,
-      arguments: JSON.parse(tc.function.arguments)
-    }));
-    return {
-      content: choice.message.content,
-      toolCalls,
-      finishReason: choice.finish_reason ?? "stop",
-      usage: response.usage ? {
-        promptTokens: response.usage.prompt_tokens,
-        completionTokens: response.usage.completion_tokens,
-        totalTokens: response.usage.total_tokens
-      } : void 0
-    };
-  }
-  async *streamChat(messages, tools) {
-    const openAITools = tools?.map(toolToOpenAI);
-    const stream = await this.client.chat.completions.create({
-      model: this.model,
-      messages,
-      tools: openAITools?.length ? openAITools : void 0,
-      temperature: 0.3,
-      stream: true
-    });
-    const toolCallBuffers = /* @__PURE__ */ new Map();
-    for await (const chunk of stream) {
-      const delta = chunk.choices[0]?.delta;
-      if (!delta) continue;
-      if (delta.content) {
-        yield { type: "text", content: delta.content };
-      }
-      if (delta.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          if (!toolCallBuffers.has(tc.index)) {
-            toolCallBuffers.set(tc.index, {
-              id: tc.id ?? "",
-              name: tc.function?.name ?? "",
-              args: ""
-            });
-            if (tc.function?.name) {
-              yield {
-                type: "tool_call_start",
-                toolCall: { id: tc.id, name: tc.function.name }
-              };
-            }
-          }
-          const buffer = toolCallBuffers.get(tc.index);
-          if (tc.id) buffer.id = tc.id;
-          if (tc.function?.name) buffer.name = tc.function.name;
-          if (tc.function?.arguments) {
-            buffer.args += tc.function.arguments;
-            yield {
-              type: "tool_call_delta",
-              content: tc.function.arguments,
-              toolCall: { id: buffer.id, name: buffer.name }
-            };
-          }
-        }
-      }
-      if (chunk.choices[0]?.finish_reason === "tool_calls") {
-        for (const [, buffer] of toolCallBuffers) {
-          let args = {};
-          try {
-            args = JSON.parse(buffer.args);
-          } catch {
-          }
-          yield {
-            type: "tool_call_end",
-            toolCall: { id: buffer.id, name: buffer.name, arguments: args }
-          };
-        }
-        toolCallBuffers.clear();
-      }
-    }
-    yield { type: "done" };
-  }
-};
-function toolToOpenAI(tool29) {
-  return {
-    type: "function",
-    function: {
-      name: tool29.name,
-      description: tool29.description,
-      parameters: tool29.parameters
-    }
-  };
-}
+// src/agent/loop.ts
+init_provider();
 
 // src/agent/system-prompt.ts
 init_internal_memory();
@@ -4745,6 +6455,23 @@ When the user asks you to build or create objects (parts, trees, houses, terrain
 **ALWAYS use \`create_ui\` for building UI.** It creates the entire UI tree in ONE call \u2014 no run_code, no get_class_info needed.
 Do NOT use run_code for UI creation. Do NOT call get_class_info before create_ui \u2014 it already handles all types natively.
 
+### UI Pre-Flight \u2014 ASK BEFORE BUILDING
+Before creating any non-trivial UI (more than a single element), **ask the user these questions** to avoid rework:
+
+**A) Device scaling** \u2014 "Should this UI scale for mobile/tablet, or is it PC-only?"
+  - If mobile-compatible: use Scale-based sizing (e.g. \`[0.3, 0, 0.05, 0]\`), add \`UIAspectRatioConstraint\` where needed, use \`TextScaled = true\` or sensible \`AutomaticSize\`, avoid fixed pixel sizes for main containers.
+  - If PC-only: pixel offsets are fine.
+
+**B) ScreenGui structure** \u2014 "Should all panels live in one ScreenGui, or separate ScreenGuis per panel?"
+  - One ScreenGui: simpler hierarchy, easier to show/hide everything at once.
+  - Separate ScreenGuis: independent ZIndex control, can toggle individual panels, better for modular systems.
+
+**C) Font & style** \u2014 "Any preferred font, color scheme, or style reference?"
+  - Default to \`Roboto\` if no preference stated. Use FontFace with Weight=\`Bold\` for bold variants.
+  - If user provides a screenshot or reference, match its style closely (transparency, stroke, colors, spacing).
+
+Skip these questions only if the user has already specified preferences, or the task is trivially small (e.g. "add a TextLabel").
+
 \`create_ui\` takes a declarative JSON tree and builds everything in a single Studio round-trip:
 \`\`\`json
 {
@@ -4853,6 +6580,20 @@ The \`get_class_info\` tool queries Roblox's ReflectionService to return the com
 
 Use it whenever you're unsure about property names or types. It's fast and cached.
 
+## Roblox Creator Docs API Reference
+Use \`search_roblox_api\` and \`get_roblox_api_reference\` when you need documented Roblox engine API information:
+- Works even when Studio is not connected.
+- Covers classes, datatypes, enums, globals, and libraries from Roblox/creator-docs.
+- Includes summaries, descriptions, tags, deprecation notes, security, thread safety, parameters, and returns.
+- Prefer it before guessing unfamiliar APIs, enum values, datatype constructors, service methods, or deprecated members.
+- When Studio is connected and you need the live engine schema for a class, use \`get_class_info\`; when you need documentation and usage guidance, use \`get_roblox_api_reference\`.
+
+## Multi-Agent Coordination
+Use \`run_parallel_task\` for broad tasks that benefit from parallel inspection, such as organizing an entire UI, auditing a large system, or comparing several independent branches.
+- Worker agents are proposal-only: they inspect with read tools and propose scoped changes.
+- The coordinator owns all writes, checks path ownership, rejects conflicts, applies safe tool calls serially, and verifies results.
+- Prefer normal single-agent execution for small, direct edits.
+
 ${INTERNAL_MEMORY}`);
   return parts.join("\n");
 }
@@ -4959,6 +6700,343 @@ ${summaryText}`
 init_config();
 init_config();
 init_store();
+
+// src/agent/planner.ts
+init_json_response();
+function createPlan(goal, stepDescriptions) {
+  return {
+    goal,
+    steps: stepDescriptions.map((desc) => ({
+      description: desc,
+      status: "pending"
+    })),
+    createdAt: Date.now()
+  };
+}
+function updateStepStatus(plan, index, status, result) {
+  if (index < 0 || index >= plan.steps.length) return plan;
+  const steps = [...plan.steps];
+  steps[index] = { ...steps[index], status, result };
+  return { ...plan, steps };
+}
+function getNextPendingStep(plan) {
+  for (let i = 0; i < plan.steps.length; i++) {
+    if (plan.steps[i].status === "pending") {
+      return { index: i, step: plan.steps[i] };
+    }
+  }
+  return null;
+}
+function isPlanComplete(plan) {
+  return plan.steps.every((s) => s.status === "done" || s.status === "failed");
+}
+async function createExecutionPlan(opts) {
+  const prompt = [
+    "You are the Dominus planning module.",
+    "Turn the goal into a short execution plan with verifiable steps.",
+    "Return JSON only in this shape:",
+    '{"goal":"...","steps":["..."],"acceptanceCriteria":["..."],"notes":["..."]}',
+    "",
+    `Goal: ${opts.goal}`,
+    `Task kind: ${opts.taskProfile.kind}`,
+    `Fidelity: ${opts.taskProfile.fidelity}`,
+    `Needs visual accuracy: ${opts.taskProfile.needsVisualAccuracy ? "yes" : "no"}`,
+    "Existing acceptance criteria:",
+    ...opts.taskProfile.acceptanceCriteria.map((item) => `- ${item}`),
+    "",
+    "Planning rules:",
+    "- Produce 3 to 6 steps.",
+    "- Each step should be actionable and specific to Roblox Studio tool work.",
+    "- Include at least one explicit verification-oriented step.",
+    "- For UI fidelity tasks, include evidence gathering and read-back comparison.",
+    "- Keep notes short and practical."
+  ].join("\n");
+  try {
+    const response = await opts.ai.chat([{ role: "system", content: prompt }]);
+    const parsed = parseJsonResponse(response.content);
+    if (!parsed) {
+      return createFallbackExecutionPlan(opts.goal, opts.taskProfile);
+    }
+    return normalizeExecutionPlan(parsed, opts.goal, opts.taskProfile);
+  } catch {
+    return createFallbackExecutionPlan(opts.goal, opts.taskProfile);
+  }
+}
+function createFallbackExecutionPlan(goal, taskProfile) {
+  const steps = taskProfile.kind === "ui_port" ? [
+    "Inspect the target UI requirements and identify the exact hierarchy and visual constraints.",
+    "Build or convert the Roblox UI using the dedicated UI tools.",
+    "Read back the resulting UI tree and key properties to compare against the target.",
+    "Fix any mismatches in layout, typography, stroke, spacing, or layering."
+  ] : taskProfile.kind === "ui_build" ? [
+    "Inspect the relevant parent and any existing UI context.",
+    "Create the requested UI with the dedicated UI tools.",
+    "Verify the created hierarchy and important properties."
+  ] : taskProfile.kind === "script_edit" ? [
+    "Read the relevant scripts and gather context before changing code.",
+    "Apply the requested code changes with dedicated tools.",
+    "Read the script back and run checks for errors or regressions."
+  ] : [
+    "Inspect the current Roblox context relevant to the request.",
+    "Execute the requested change with dedicated tools.",
+    "Verify the result before marking the task complete."
+  ];
+  return {
+    ...createPlan(goal, steps),
+    acceptanceCriteria: [...taskProfile.acceptanceCriteria],
+    notes: buildFallbackNotes(taskProfile),
+    taskProfile
+  };
+}
+function formatExecutionPlan(plan) {
+  const lines = [`Plan for: ${plan.goal}`];
+  for (let i = 0; i < plan.steps.length; i++) {
+    lines.push(`${i + 1}. ${plan.steps[i].description}`);
+  }
+  if (plan.acceptanceCriteria.length > 0) {
+    lines.push("Acceptance criteria:");
+    for (const criterion of plan.acceptanceCriteria) {
+      lines.push(`- ${criterion}`);
+    }
+  }
+  return lines.join("\n");
+}
+function normalizeExecutionPlan(parsed, fallbackGoal, taskProfile) {
+  const goal = typeof parsed.goal === "string" && parsed.goal.trim() ? parsed.goal.trim() : fallbackGoal;
+  const stepDescriptions = Array.isArray(parsed.steps) ? parsed.steps.map((step) => sanitizeLine(step)).filter(Boolean).slice(0, 6) : [];
+  const acceptanceCriteria = Array.isArray(parsed.acceptanceCriteria) ? parsed.acceptanceCriteria.map((item) => sanitizeLine(item)).filter(Boolean).slice(0, 8) : [];
+  const notes = Array.isArray(parsed.notes) ? parsed.notes.map((item) => sanitizeLine(item)).filter(Boolean).slice(0, 6) : [];
+  const fallback = createFallbackExecutionPlan(fallbackGoal, taskProfile);
+  return {
+    ...createPlan(
+      goal,
+      stepDescriptions.length >= 2 ? stepDescriptions : fallback.steps.map((step) => step.description)
+    ),
+    acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : fallback.acceptanceCriteria,
+    notes: notes.length > 0 ? notes : fallback.notes,
+    taskProfile
+  };
+}
+function buildFallbackNotes(taskProfile) {
+  if (taskProfile.kind === "ui_port") {
+    return [
+      "Do not treat visual approximation as success.",
+      "Use read-back evidence for UI properties before finishing."
+    ];
+  }
+  if (taskProfile.kind === "script_edit") {
+    return [
+      "Prefer reading existing code before rewriting it.",
+      "Verify script edits by reading them back."
+    ];
+  }
+  return ["Keep the agent aligned to the explicit user goal and verify important effects."];
+}
+function sanitizeLine(value) {
+  return String(value ?? "").replace(/\s+/g, " ").trim();
+}
+
+// src/agent/task-profile.ts
+var UI_CUES = [
+  "ui",
+  "gui",
+  "screen",
+  "frame",
+  "textlabel",
+  "textbutton",
+  "imagebutton",
+  "imagelabel",
+  "html",
+  "css",
+  "react roblox",
+  "roact",
+  "fusion"
+];
+var PORT_CUES = ["port", "convert", "copy", "recreate", "translate", "match"];
+var STRICT_CUES = [
+  "1:1",
+  "exact",
+  "exactly",
+  "pixel perfect",
+  "pixel-perfect",
+  "identical",
+  "same sizing",
+  "same font",
+  "same stroke",
+  "same spacing"
+];
+function buildTaskProfile(userMessage) {
+  const lower = userMessage.toLowerCase();
+  const cues = /* @__PURE__ */ new Set();
+  for (const cue of [...UI_CUES, ...PORT_CUES, ...STRICT_CUES]) {
+    if (lower.includes(cue)) cues.add(cue);
+  }
+  const isUiTask = containsAny(lower, UI_CUES);
+  const isPortTask = containsAny(lower, PORT_CUES);
+  const strictFidelity = containsAny(lower, STRICT_CUES);
+  if (isUiTask && (isPortTask || strictFidelity)) {
+    return {
+      kind: "ui_port",
+      fidelity: strictFidelity ? "strict" : "normal",
+      needsVisualAccuracy: true,
+      cues: Array.from(cues),
+      acceptanceCriteria: [
+        "Recreate the same UI hierarchy and element structure.",
+        "Match sizing, position, anchors, spacing, and layout behavior.",
+        "Match fonts, weights, text sizing, alignment, and transparency.",
+        "Match strokes, borders, corner radii, gradients, and layering.",
+        "Read back or serialize the result instead of assuming it is correct."
+      ]
+    };
+  }
+  if (isUiTask) {
+    return {
+      kind: "ui_build",
+      fidelity: strictFidelity ? "strict" : "normal",
+      needsVisualAccuracy: strictFidelity,
+      cues: Array.from(cues),
+      acceptanceCriteria: [
+        "Create the requested UI structure in the correct parent.",
+        "Use appropriate scaling and layout properties for the requested target.",
+        "Verify the created UI tree and important properties after building."
+      ]
+    };
+  }
+  if (containsAny(lower, ["script", "module", "refactor", "fix bug", "luau", "code"])) {
+    return {
+      kind: "script_edit",
+      fidelity: "normal",
+      needsVisualAccuracy: false,
+      cues: Array.from(cues),
+      acceptanceCriteria: [
+        "Make the requested code change without drifting from the user goal.",
+        "Read back edited scripts after writing them.",
+        "Check for runtime or test errors when execution is involved."
+      ]
+    };
+  }
+  return {
+    kind: "general",
+    fidelity: strictFidelity ? "strict" : "normal",
+    needsVisualAccuracy: false,
+    cues: Array.from(cues),
+    acceptanceCriteria: [
+      "Complete the user goal directly.",
+      "Prefer dedicated tools over generic execution.",
+      "Verify the effects of important changes before finishing."
+    ]
+  };
+}
+function containsAny(text, cues) {
+  return cues.some((cue) => text.includes(cue));
+}
+
+// src/agent/critic.ts
+init_json_response();
+async function critiqueStep(opts) {
+  const step = opts.plan.steps[opts.stepIndex];
+  if (!step) {
+    return {
+      verdict: "blocked",
+      summary: "No active step was available for critique.",
+      missingCriteria: []
+    };
+  }
+  const prompt = [
+    "You are the Dominus alignment critic.",
+    "Decide whether the current plan step is actually complete, needs another attempt, or is blocked.",
+    "Be strict about missing evidence.",
+    "Return JSON only in this shape:",
+    '{"verdict":"done|retry|blocked","summary":"...","missingCriteria":["..."],"nextAction":"..."}',
+    "",
+    `Goal: ${opts.plan.goal}`,
+    `Current step: ${step.description}`,
+    `Task kind: ${opts.plan.taskProfile.kind}`,
+    `Fidelity: ${opts.plan.taskProfile.fidelity}`,
+    "Acceptance criteria:",
+    ...opts.plan.acceptanceCriteria.map((item) => `- ${item}`),
+    "",
+    "Assistant summary:",
+    opts.assistantText || "(no assistant summary)",
+    "",
+    "Recent tool evidence:",
+    JSON.stringify(summarizeToolResults(opts.toolResults), null, 2),
+    "",
+    "Rules:",
+    "- For UI fidelity tasks, missing evidence about sizing, fonts, strokes, spacing, or hierarchy should usually mean retry.",
+    "- If there was a failed tool result or failed verification, prefer retry unless the task is clearly blocked.",
+    "- Use blocked only when the step cannot continue without outside input or a missing dependency."
+  ].join("\n");
+  try {
+    const response = await opts.ai.chat([{ role: "system", content: prompt }]);
+    const parsed = parseJsonResponse(response.content);
+    if (!parsed?.verdict || !parsed.summary) {
+      return fallbackStepReview(opts);
+    }
+    return {
+      verdict: normalizeVerdict(parsed.verdict),
+      summary: parsed.summary.trim(),
+      missingCriteria: Array.isArray(parsed.missingCriteria) ? parsed.missingCriteria.map((item) => String(item).trim()).filter(Boolean) : [],
+      nextAction: typeof parsed.nextAction === "string" ? parsed.nextAction.trim() : void 0
+    };
+  } catch {
+    return fallbackStepReview(opts);
+  }
+}
+function fallbackStepReview(opts) {
+  const failedResult = opts.toolResults.find(({ result }) => !result.success);
+  if (failedResult) {
+    return {
+      verdict: "retry",
+      summary: `The ${failedResult.call.name} result failed, so the step should be retried after correction.`,
+      missingCriteria: ["Resolve the failing tool or verification result."],
+      nextAction: `Inspect and fix the failure from ${failedResult.call.name}.`
+    };
+  }
+  if (opts.plan.taskProfile.needsVisualAccuracy && opts.toolResults.length === 0) {
+    return {
+      verdict: "retry",
+      summary: "A visual fidelity step needs concrete evidence from Studio tools before it can be considered done.",
+      missingCriteria: ["Collect read-back evidence for the relevant UI properties or tree."],
+      nextAction: "Inspect or serialize the UI and compare it against the requested target."
+    };
+  }
+  if (!opts.assistantText.trim() && opts.toolResults.length === 0) {
+    return {
+      verdict: "blocked",
+      summary: "The step produced neither explanation nor tool evidence.",
+      missingCriteria: ["Produce a concrete action or explain the blocker."]
+    };
+  }
+  return {
+    verdict: "done",
+    summary: "The step produced enough evidence to continue.",
+    missingCriteria: []
+  };
+}
+function summarizeToolResults(toolResults) {
+  return toolResults.map(({ call, result }) => ({
+    tool: call.name,
+    args: trimJson(call.arguments),
+    success: result.success,
+    error: result.error,
+    data: trimJson(result.data)
+  }));
+}
+function trimJson(value) {
+  if (value == null) return value;
+  const raw = JSON.stringify(value);
+  if (raw.length <= 1200) return value;
+  return `${raw.slice(0, 1200)}...`;
+}
+function normalizeVerdict(value) {
+  if (value === "done" || value === "retry" || value === "blocked") return value;
+  return "retry";
+}
+
+// src/agent/loop.ts
+init_verifier();
+init_coordinator();
 var AgentLoop = class {
   ai;
   server;
@@ -4993,10 +7071,11 @@ var AgentLoop = class {
     this.projectId = projectId;
   }
   async *run(userMessage, imageAttachment) {
+    const storedUserMessage = userMessage + (imageAttachment ? " [image attached]" : "");
     storeMessage({
       sessionId: this.sessionId,
       role: "user",
-      content: userMessage + (imageAttachment ? " [image attached]" : ""),
+      content: storedUserMessage,
       createdAt: Date.now()
     });
     const { messages } = buildContext({
@@ -5006,6 +7085,7 @@ var AgentLoop = class {
       projectId: this.projectId,
       sessionId: this.sessionId
     });
+    this.conversationHistory.push({ role: "user", content: storedUserMessage });
     if (imageAttachment) {
       const lastMsg = messages[messages.length - 1];
       if (lastMsg && lastMsg.role === "user") {
@@ -5022,76 +7102,167 @@ var AgentLoop = class {
       }
     }
     const toolCtx = this.createToolContext();
-    const allTools = this.tools.getAll();
-    let currentMessages = [...messages];
+    await this.tools.ready();
+    const baseTools = this.tools.getAll();
+    const coordinator = new MultiAgentCoordinator(this.ai, baseTools);
+    const allTools = [...baseTools, coordinator.getMetaTool()];
+    const taskProfile = buildTaskProfile(userMessage);
+    if (coordinator.shouldAutoTrigger(userMessage)) {
+      const events = [];
+      const result = await coordinator.execute(
+        {
+          goal: userMessage,
+          rootPath: inferRootPath(userMessage),
+          taskType: taskProfile.kind.includes("ui") ? "ui" : taskProfile.kind
+        },
+        toolCtx,
+        (event) => events.push(event)
+      );
+      for (const event of events) yield event;
+      const summary = formatMultiAgentResult(result);
+      yield { type: "text", content: summary };
+      storeMessage({
+        sessionId: this.sessionId,
+        role: "assistant",
+        content: summary,
+        createdAt: Date.now()
+      });
+      this.conversationHistory.push({ role: "assistant", content: summary });
+      yield { type: "done" };
+      return;
+    }
+    let plan = await createExecutionPlan({
+      ai: this.ai,
+      goal: userMessage,
+      taskProfile
+    });
+    yield { type: "plan", steps: plan.steps };
+    yield { type: "text", content: formatExecutionPlan(plan) };
+    let currentMessages = [
+      ...messages,
+      {
+        role: "system",
+        content: buildExecutionContext(plan)
+      }
+    ];
     let iteration = 0;
-    while (iteration < this.maxIterations) {
-      iteration++;
-      try {
-        const response = await this.ai.chat(currentMessages, allTools);
-        if (response.content) {
-          yield { type: "text", content: response.content };
-          storeMessage({
-            sessionId: this.sessionId,
+    while (iteration < this.maxIterations && !isPlanComplete(plan)) {
+      const nextStep = getNextPendingStep(plan);
+      if (!nextStep) break;
+      plan = updateStepStatus(plan, nextStep.index, "running");
+      yield { type: "plan_progress", stepIndex: nextStep.index, status: "running" };
+      let stepDone = false;
+      let stepAttempts = 0;
+      while (!stepDone && stepAttempts <= this.maxRetries && iteration < this.maxIterations) {
+        stepAttempts++;
+        iteration++;
+        currentMessages.push({
+          role: "system",
+          content: buildCurrentStepPrompt(plan, nextStep.index)
+        });
+        try {
+          const response = await this.ai.chat(currentMessages, allTools);
+          const assistantMsg = {
             role: "assistant",
-            content: response.content,
-            createdAt: Date.now()
-          });
-          this.conversationHistory.push({ role: "assistant", content: response.content });
-        }
-        if (response.toolCalls.length === 0) {
-          break;
-        }
-        const toolResults = [];
-        for (const call of response.toolCalls) {
-          yield { type: "tool_call", tool: call.name, args: call.arguments };
-          const result = await this.tools.execute(call, toolCtx);
-          toolResults.push({ call, result });
-          yield { type: "tool_result", tool: call.name, result };
-          storeMessage({
-            sessionId: this.sessionId,
-            role: "tool_call",
-            content: JSON.stringify({ name: call.name, args: call.arguments }),
-            toolName: call.name,
-            createdAt: Date.now()
-          });
-          storeMessage({
-            sessionId: this.sessionId,
-            role: "tool_result",
-            content: JSON.stringify(result),
-            toolName: call.name,
-            createdAt: Date.now()
-          });
-        }
-        const assistantMsg = {
-          role: "assistant",
-          content: response.content ?? null,
-          tool_calls: response.toolCalls.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
-          }))
-        };
-        currentMessages.push(assistantMsg);
-        for (const { call, result } of toolResults) {
-          currentMessages.push({
-            role: "tool",
-            content: JSON.stringify(result),
-            tool_call_id: call.id
-          });
-        }
-        this.conversationHistory.push(assistantMsg);
-        for (const { call, result } of toolResults) {
-          this.conversationHistory.push({
-            role: "tool",
-            content: JSON.stringify(result),
-            tool_call_id: call.id
+            content: response.content ?? null,
+            ...response.toolCalls.length > 0 ? {
+              tool_calls: response.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+              }))
+            } : {}
+          };
+          currentMessages.push(assistantMsg);
+          this.conversationHistory.push(assistantMsg);
+          if (response.content) {
+            yield { type: "text", content: response.content };
+            storeMessage({
+              sessionId: this.sessionId,
+              role: "assistant",
+              content: response.content,
+              createdAt: Date.now()
+            });
+          }
+          const toolResults = [];
+          for (const call of response.toolCalls) {
+            yield { type: "tool_call", tool: call.name, args: call.arguments };
+            const result = call.name === "run_parallel_task" ? await this.executeParallelTaskMetaCall(call.arguments, coordinator, toolCtx) : await this.tools.execute(call, toolCtx);
+            toolResults.push({ call, result });
+            if (call.name === "run_parallel_task") {
+              const events = extractMultiAgentEvents(result);
+              for (const event of events) yield event;
+            }
+            yield { type: "tool_result", tool: call.name, result };
+            storeMessage({
+              sessionId: this.sessionId,
+              role: "tool_call",
+              content: JSON.stringify({ name: call.name, args: call.arguments }),
+              toolName: call.name,
+              createdAt: Date.now()
+            });
+            storeMessage({
+              sessionId: this.sessionId,
+              role: "tool_result",
+              content: JSON.stringify(result),
+              toolName: call.name,
+              createdAt: Date.now()
+            });
+            currentMessages.push({
+              role: "tool",
+              content: JSON.stringify(result),
+              tool_call_id: call.id
+            });
+            this.conversationHistory.push({
+              role: "tool",
+              content: JSON.stringify(result),
+              tool_call_id: call.id
+            });
+          }
+          const verificationFailures = await this.runVerificationChecks(toolResults, toolCtx);
+          if (verificationFailures.length > 0) {
+            const failureMessage = formatVerificationFailures(verificationFailures);
+            currentMessages.push({ role: "system", content: failureMessage });
+            yield { type: "text", content: failureMessage };
+            if (stepAttempts > this.maxRetries) {
+              plan = updateStepStatus(plan, nextStep.index, "failed", failureMessage);
+              yield { type: "plan_progress", stepIndex: nextStep.index, status: "failed" };
+              stepDone = true;
+            }
+            continue;
+          }
+          const review = await critiqueStep({
+            ai: this.ai,
+            plan,
+            stepIndex: nextStep.index,
+            assistantText: response.content ?? "",
+            toolResults
           });
+          if (review.verdict === "done") {
+            plan = updateStepStatus(plan, nextStep.index, "done", review.summary);
+            currentMessages.push({
+              role: "system",
+              content: `Step complete: ${review.summary}`
+            });
+            yield { type: "plan_progress", stepIndex: nextStep.index, status: "done" };
+            stepDone = true;
+            continue;
+          }
+          const feedback = formatCriticFeedback(review);
+          currentMessages.push({ role: "system", content: feedback });
+          yield { type: "text", content: feedback };
+          if (review.verdict === "blocked" || stepAttempts > this.maxRetries) {
+            plan = updateStepStatus(plan, nextStep.index, "failed", review.summary);
+            yield { type: "plan_progress", stepIndex: nextStep.index, status: "failed" };
+            stepDone = true;
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          yield { type: "error", message };
+          plan = updateStepStatus(plan, nextStep.index, "failed", message);
+          yield { type: "plan_progress", stepIndex: nextStep.index, status: "failed" };
+          stepDone = true;
         }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        yield { type: "error", message };
-        break;
       }
     }
     yield { type: "done" };
@@ -5136,102 +7307,133 @@ var AgentLoop = class {
       config: createConfigAccess()
     };
   }
+  async runVerificationChecks(toolResults, toolCtx) {
+    const checks = toolResults.flatMap(({ call, result }) => inferVerifyChecks(call, result));
+    const failures = [];
+    for (const check of checks) {
+      const verification = await verifyAction(check, toolCtx);
+      if (!verification.success) {
+        failures.push(verification);
+      }
+    }
+    return failures;
+  }
+  async executeParallelTaskMetaCall(args, coordinator, toolCtx) {
+    const events = [];
+    const result = await coordinator.execute(normalizeParallelTaskArgs(args), toolCtx, (event) => {
+      events.push(event);
+    });
+    return {
+      success: result.verificationFailures.length === 0 && result.applied.every((item) => item.result.success),
+      data: {
+        ...result,
+        events,
+        summary: formatMultiAgentResult(result)
+      }
+    };
+  }
   clearHistory() {
     this.conversationHistory = [];
     this.sessionId = nanoid();
   }
 };
-
-// src/tools/registry.ts
-var ToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  register(tool29) {
-    if (this.tools.has(tool29.name)) {
-      throw new Error(`Tool already registered: ${tool29.name}`);
-    }
-    this.tools.set(tool29.name, tool29);
+function normalizeParallelTaskArgs(args) {
+  return {
+    goal: String(args.goal ?? ""),
+    rootPath: typeof args.rootPath === "string" ? args.rootPath : void 0,
+    maxWorkers: typeof args.maxWorkers === "number" ? args.maxWorkers : void 0,
+    constraints: typeof args.constraints === "string" ? args.constraints : void 0,
+    taskType: typeof args.taskType === "string" ? args.taskType : void 0
+  };
+}
+function inferRootPath(userMessage) {
+  const match = userMessage.match(/\b(?:StarterGui|PlayerGui|Workspace|ReplicatedStorage|ServerScriptService|StarterPlayer)(?:\.[A-Za-z0-9_]+)*/);
+  return match?.[0];
+}
+function formatMultiAgentResult(result) {
+  const lines = [
+    `Multi-agent task complete: ${result.goal}`,
+    `Workers: ${result.assignments.length}`,
+    `Accepted proposals: ${result.decision.accepted.length}`,
+    `Rejected proposals: ${result.decision.rejected.length}`,
+    `Applied tool calls: ${result.applied.length}`,
+    `Verification failures: ${result.verificationFailures.length}`
+  ];
+  for (const accepted of result.decision.accepted) {
+    lines.push(`- ${accepted.workerId}: ${accepted.proposal.summary}`);
   }
-  get(name) {
-    return this.tools.get(name);
+  for (const rejected of result.decision.rejected) {
+    lines.push(`- Rejected ${rejected.workerId}: ${rejected.reason}`);
   }
-  getAll() {
-    return Array.from(this.tools.values());
+  return lines.join("\n");
+}
+function extractMultiAgentEvents(result) {
+  const data = result.data;
+  if (!data || typeof data !== "object") return [];
+  const events = data.events;
+  if (!Array.isArray(events)) return [];
+  return events.filter((event) => {
+    return event && typeof event === "object" && "type" in event;
+  });
+}
+function buildExecutionContext(plan) {
+  const lines = [
+    "You are operating in structured execution mode.",
+    "Follow the plan, stay aligned to the goal, and verify before moving on.",
+    `Goal: ${plan.goal}`,
+    `Task kind: ${plan.taskProfile.kind}`,
+    `Fidelity: ${plan.taskProfile.fidelity}`,
+    "Acceptance criteria:",
+    ...plan.acceptanceCriteria.map((item) => `- ${item}`)
+  ];
+  if (plan.notes.length > 0) {
+    lines.push("Execution notes:");
+    lines.push(...plan.notes.map((note) => `- ${note}`));
   }
-  getSchemas() {
-    return this.getAll();
+  return lines.join("\n");
+}
+function buildCurrentStepPrompt(plan, stepIndex) {
+  const step = plan.steps[stepIndex];
+  return [
+    `Current step ${stepIndex + 1}/${plan.steps.length}: ${step.description}`,
+    "Focus on this step only.",
+    "Use Studio tools to gather evidence and make changes.",
+    "Prefer dedicated tools over run_code.",
+    "Before considering the step complete, produce evidence that it satisfies the relevant acceptance criteria.",
+    plan.taskProfile.needsVisualAccuracy ? "For UI fidelity work, do not approximate. Check exact layout, font, stroke, spacing, and hierarchy details." : "Keep the work tightly aligned to the requested outcome."
+  ].join("\n");
+}
+function formatVerificationFailures(failures) {
+  const lines = ["Verification failed after the recent tool actions:"];
+  for (const failure of failures) {
+    lines.push(`- ${failure.error ?? "Unknown verification failure"}`);
   }
-  async execute(call, ctx) {
-    const tool29 = this.tools.get(call.name);
-    if (!tool29) {
-      return { success: false, error: `Unknown tool: ${call.name}` };
-    }
-    try {
-      return await tool29.execute(call.arguments, ctx);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { success: false, error: message };
-    }
+  lines.push("Correct the mismatch before moving to the next plan step.");
+  return lines.join("\n");
+}
+function formatCriticFeedback(review) {
+  const lines = [`Critic review: ${review.summary}`];
+  for (const item of review.missingCriteria) {
+    lines.push(`- Missing: ${item}`);
   }
-  listNames() {
-    return Array.from(this.tools.keys());
+  if (review.nextAction) {
+    lines.push(`Next action: ${review.nextAction}`);
   }
-};
-function createDefaultRegistry() {
-  const registry = new ToolRegistry();
-  const toolModules = [
-    Promise.resolve().then(() => (init_read_script(), read_script_exports)),
-    Promise.resolve().then(() => (init_edit_script(), edit_script_exports)),
-    Promise.resolve().then(() => (init_run_code(), run_code_exports)),
-    Promise.resolve().then(() => (init_get_explorer(), get_explorer_exports)),
-    Promise.resolve().then(() => (init_get_properties(), get_properties_exports)),
-    Promise.resolve().then(() => (init_get_descendants_properties(), get_descendants_properties_exports)),
-    Promise.resolve().then(() => (init_set_properties(), set_properties_exports)),
-    Promise.resolve().then(() => (init_insert_instance(), insert_instance_exports)),
-    Promise.resolve().then(() => (init_delete_instance(), delete_instance_exports)),
-    Promise.resolve().then(() => (init_get_output(), get_output_exports)),
-    Promise.resolve().then(() => (init_get_selection(), get_selection_exports)),
-    Promise.resolve().then(() => (init_search_scripts(), search_scripts_exports)),
-    Promise.resolve().then(() => (init_run_tests(), run_tests_exports)),
-    Promise.resolve().then(() => (init_get_class_info(), get_class_info_exports)),
-    Promise.resolve().then(() => (init_create_ui(), create_ui_exports)),
-    Promise.resolve().then(() => (init_execute_run_test(), execute_run_test_exports)),
-    Promise.resolve().then(() => (init_execute_play_test(), execute_play_test_exports)),
-    Promise.resolve().then(() => (init_create_part(), create_part_exports)),
-    Promise.resolve().then(() => (init_clone_instance(), clone_instance_exports)),
-    Promise.resolve().then(() => (init_group_instances(), group_instances_exports)),
-    Promise.resolve().then(() => (init_build_multiple(), build_multiple_exports)),
-    Promise.resolve().then(() => (init_serialize_ui(), serialize_ui_exports)),
-    Promise.resolve().then(() => (init_move_instance(), move_instance_exports)),
-    Promise.resolve().then(() => (init_bulk_set_properties(), bulk_set_properties_exports)),
-    Promise.resolve().then(() => (init_find_replace_scripts(), find_replace_scripts_exports)),
-    Promise.resolve().then(() => (init_recall(), recall_exports)),
-    Promise.resolve().then(() => (init_remember(), remember_exports)),
-    Promise.resolve().then(() => (init_upload_asset(), upload_asset_exports))
-  ];
-  void Promise.all(
-    toolModules.map(async (mod) => {
-      const m = await mod;
-      if (m.tool) registry.register(m.tool);
-    })
-  );
-  void Promise.resolve().then(() => (init_undo_redo(), undo_redo_exports)).then((m) => {
-    registry.register(m.undoTool);
-    registry.register(m.redoTool);
-  });
-  return registry;
+  return lines.join("\n");
 }
 
 // src/index.tsx
+init_registry();
 init_store();
 init_config();
-var CACHE_DIR = path4.join(os3.homedir(), ".dominus");
-var CACHE_FILE = path4.join(CACHE_DIR, "update-check.json");
+var CACHE_DIR = path5.join(os3.homedir(), ".dominus");
+var CACHE_FILE = path5.join(CACHE_DIR, "update-check.json");
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 var NPM_PACKAGE = "dominus-cli";
 function readCache() {
   try {
-    if (fs5.existsSync(CACHE_FILE)) {
-      return JSON.parse(fs5.readFileSync(CACHE_FILE, "utf-8"));
+    if (fs6.existsSync(CACHE_FILE)) {
+      return JSON.parse(fs6.readFileSync(CACHE_FILE, "utf-8"));
     }
   } catch {
   }
@@ -5239,8 +7441,8 @@ function readCache() {
 }
 function writeCache(cache) {
   try {
-    if (!fs5.existsSync(CACHE_DIR)) fs5.mkdirSync(CACHE_DIR, { recursive: true });
-    fs5.writeFileSync(CACHE_FILE, JSON.stringify(cache), "utf-8");
+    if (!fs6.existsSync(CACHE_DIR)) fs6.mkdirSync(CACHE_DIR, { recursive: true });
+    fs6.writeFileSync(CACHE_FILE, JSON.stringify(cache), "utf-8");
   } catch {
   }
 }
@@ -5340,8 +7542,8 @@ async function autoUpdate(currentVersion) {
     try {
       const out = execSync("pnpm list -g dominus-cli", { stdio: "pipe", timeout: 1e4 }).toString();
       if (out.includes("link:")) {
-        const pkgPath = path4.resolve(__dirname$1, "..");
-        if (fs5.existsSync(path4.join(pkgPath, ".git"))) {
+        const pkgPath = path5.resolve(__dirname$1, "..");
+        if (fs6.existsSync(path5.join(pkgPath, ".git"))) {
           try {
             execSync("git pull", { cwd: pkgPath, stdio: "pipe", timeout: 3e4 });
             execSync("pnpm install", { cwd: pkgPath, stdio: "pipe", timeout: 6e4 });
@@ -5368,9 +7570,9 @@ async function autoUpdate(currentVersion) {
     return { success: false, from: currentVersion, to: info.latestVersion, error: `Update command failed: ${err}` };
   }
 }
-var __dirname$1 = path4.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1"));
-var __dirname2 = path4.dirname(fileURLToPath(import.meta.url));
-var VERSION = JSON.parse(fs5.readFileSync(path4.join(__dirname2, "..", "package.json"), "utf-8")).version;
+var __dirname$1 = path5.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1"));
+var __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
+var VERSION = JSON.parse(fs6.readFileSync(path5.join(__dirname2, "..", "package.json"), "utf-8")).version;
 var program = new Command();
 program.name("dominus").description("AI-powered autonomous agent for Roblox Studio development").version(VERSION);
 program.command("start", { isDefault: true }).description("Launch the Dominus TUI agent").option("-p, --port <port>", "WebSocket server port", "18088").action(async (opts) => {
@@ -5499,24 +7701,24 @@ program.command("update").description("Auto-update Dominus to the latest version
 });
 program.command("install-plugin").description("Build & install the Dominus plugin into Roblox Studio").action(async () => {
   const { execSync: execSync3 } = await import('child_process');
-  const packageRoot = path4.resolve(import.meta.dirname ?? __dirname2, "..");
-  const pluginDir = path4.join(packageRoot, "plugin");
-  const pluginProject = path4.join(pluginDir, "default.project.json");
-  const studioPlugins = path4.join(
+  const packageRoot = path5.resolve(import.meta.dirname ?? __dirname2, "..");
+  const pluginDir = path5.join(packageRoot, "plugin");
+  const pluginProject = path5.join(pluginDir, "default.project.json");
+  const studioPlugins = path5.join(
     os3.homedir(),
     "AppData",
     "Local",
     "Roblox",
     "Plugins"
   );
-  const destFile = path4.join(studioPlugins, "Dominus.rbxm");
-  if (!fs5.existsSync(pluginProject)) {
+  const destFile = path5.join(studioPlugins, "Dominus.rbxm");
+  if (!fs6.existsSync(pluginProject)) {
     console.log("  \u2716 Plugin source not found.");
     console.log(`  Expected at: ${pluginDir}`);
     return;
   }
-  if (!fs5.existsSync(studioPlugins)) {
-    fs5.mkdirSync(studioPlugins, { recursive: true });
+  if (!fs6.existsSync(studioPlugins)) {
+    fs6.mkdirSync(studioPlugins, { recursive: true });
   }
   let rojoAvailable = false;
   try {
@@ -5544,48 +7746,48 @@ program.command("mcp").description("Start the Dominus MCP server (for Cursor, Cl
 });
 function getMcpTargets() {
   const home = os3.homedir();
-  const appData = process.env.APPDATA || path4.join(home, "AppData", "Roaming");
-  const localAppData = process.env.LOCALAPPDATA || path4.join(home, "AppData", "Local");
+  const appData = process.env.APPDATA || path5.join(home, "AppData", "Roaming");
+  const localAppData = process.env.LOCALAPPDATA || path5.join(home, "AppData", "Local");
   const cwd = process.cwd();
   return [
     {
       name: "Cursor (project)",
-      configPath: path4.join(cwd, ".cursor", "mcp.json"),
+      configPath: path5.join(cwd, ".cursor", "mcp.json"),
       keyPath: ["mcpServers"]
     },
     {
       name: "Cursor (global)",
-      configPath: path4.join(home, ".cursor", "mcp.json"),
+      configPath: path5.join(home, ".cursor", "mcp.json"),
       keyPath: ["mcpServers"]
     },
     {
       name: "Claude Desktop",
-      configPath: path4.join(appData, "Claude", "claude_desktop_config.json"),
+      configPath: path5.join(appData, "Claude", "claude_desktop_config.json"),
       keyPath: ["mcpServers"]
     },
     {
       name: "Claude Code",
-      configPath: path4.join(home, ".claude.json"),
+      configPath: path5.join(home, ".claude.json"),
       keyPath: ["mcpServers"]
     },
     {
       name: "Windsurf (project)",
-      configPath: path4.join(cwd, ".windsurf", "mcp.json"),
+      configPath: path5.join(cwd, ".windsurf", "mcp.json"),
       keyPath: ["mcpServers"]
     },
     {
       name: "Windsurf (global)",
-      configPath: path4.join(home, ".codeium", "windsurf", "mcp_config.json"),
+      configPath: path5.join(home, ".codeium", "windsurf", "mcp_config.json"),
       keyPath: ["mcpServers"]
     },
     {
       name: "VS Code (project)",
-      configPath: path4.join(cwd, ".vscode", "mcp.json"),
+      configPath: path5.join(cwd, ".vscode", "mcp.json"),
       keyPath: ["servers"]
     },
     {
       name: "VS Code (global)",
-      configPath: path4.join(localAppData, "Code", "User", "settings.json"),
+      configPath: path5.join(localAppData, "Code", "User", "settings.json"),
       keyPath: ["mcp", "servers"]
     }
   ];
@@ -5597,9 +7799,9 @@ var dominusEntry = {
 };
 function injectMcpConfig(target) {
   let config = {};
-  if (fs5.existsSync(target.configPath)) {
+  if (fs6.existsSync(target.configPath)) {
     try {
-      config = JSON.parse(fs5.readFileSync(target.configPath, "utf-8"));
+      config = JSON.parse(fs6.readFileSync(target.configPath, "utf-8"));
     } catch {
       config = {};
     }
@@ -5615,12 +7817,12 @@ function injectMcpConfig(target) {
     return { status: "already" };
   }
   obj["dominus"] = { ...dominusEntry };
-  const dir = path4.dirname(target.configPath);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path5.dirname(target.configPath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
-  fs5.writeFileSync(target.configPath, JSON.stringify(config, null, 2), "utf-8");
-  return { status: fs5.existsSync(target.configPath) ? "installed" : "created" };
+  fs6.writeFileSync(target.configPath, JSON.stringify(config, null, 2), "utf-8");
+  return { status: fs6.existsSync(target.configPath) ? "installed" : "created" };
 }
 program.command("mcp-install").description("Auto-install Dominus MCP into Cursor, VS Code, Claude Desktop, Windsurf, etc.").option("-a, --all", "Install to all detected editors").action(async (opts) => {
   const targets = getMcpTargets();
@@ -5642,7 +7844,7 @@ program.command("mcp-install").description("Auto-install Dominus MCP into Cursor
   }
   const detected = targets.map((t) => ({
     target: t,
-    exists: fs5.existsSync(path4.dirname(t.configPath))
+    exists: fs6.existsSync(path5.dirname(t.configPath))
   }));
   const toInstall = detected.filter((d) => d.exists);
   if (toInstall.length === 0) {
@@ -5715,23 +7917,23 @@ program.command("mcp-setup").description("Print MCP configuration for manual set
   console.log("");
 });
 function buildPluginXml(pluginDir, destFile) {
-  const srcDir = path4.join(pluginDir, "src");
-  if (!fs5.existsSync(srcDir)) {
+  const srcDir = path5.join(pluginDir, "src");
+  if (!fs6.existsSync(srcDir)) {
     console.log(`  \u2716 Plugin source directory not found: ${srcDir}`);
     return;
   }
-  const files = fs5.readdirSync(srcDir).filter((f) => f.endsWith(".lua"));
+  const files = fs6.readdirSync(srcDir).filter((f) => f.endsWith(".lua"));
   const mainFile = files.find((f) => f === "init.server.lua");
   const moduleFiles = files.filter((f) => f !== "init.server.lua");
   if (!mainFile) {
     console.log("  \u2716 init.server.lua not found in plugin source");
     return;
   }
-  const mainSource = fs5.readFileSync(path4.join(srcDir, mainFile), "utf-8");
+  const mainSource = fs6.readFileSync(path5.join(srcDir, mainFile), "utf-8");
   let moduleItems = "";
   for (const mf of moduleFiles) {
     const modName = mf.replace(".lua", "");
-    const modSource = fs5.readFileSync(path4.join(srcDir, mf), "utf-8");
+    const modSource = fs6.readFileSync(path5.join(srcDir, mf), "utf-8");
     moduleItems += `
       <Item class="ModuleScript" referent="${modName}">
         <Properties>
@@ -5749,7 +7951,7 @@ function buildPluginXml(pluginDir, destFile) {
     </Properties>${moduleItems}
   </Item>
 </roblox>`;
-  fs5.writeFileSync(destFile, rbxmx, "utf-8");
+  fs6.writeFileSync(destFile, rbxmx, "utf-8");
   console.log(`  \u2714 Plugin installed to: ${destFile}`);
   console.log("  Restart Roblox Studio to load the plugin.");
 }