dominus-cli 2.1.1 → 2.2.1

package/dist/mcp.js

@@ -1,20 +1,21 @@
 #!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import fs3 from 'fs';
-import path3 from 'path';
+import fs4 from 'fs';
+import path4 from 'path';
 import os from 'os';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
 import { EventEmitter } from 'events';
-import { WebSocket, WebSocketServer } from 'ws';
+import { WebSocket } from 'ws';
 import { nanoid } from 'nanoid';
 import { z } from 'zod';
 import * as crypto from 'crypto';
-import { randomUUID } from 'crypto';
 
-var DOMINUS_DIR = path3.join(os.homedir(), ".dominus");
-var CONFIG_PATH = path3.join(DOMINUS_DIR, "config.json");
-path3.join(DOMINUS_DIR, "dominus.db");
-path3.join(DOMINUS_DIR, "rules.json");
+var DOMINUS_DIR = path4.join(os.homedir(), ".dominus");
+var CONFIG_PATH = path4.join(DOMINUS_DIR, "config.json");
+path4.join(DOMINUS_DIR, "dominus.db");
+path4.join(DOMINUS_DIR, "rules.json");
 var DEFAULTS = {
   provider: "openai",
   apiBaseUrl: "",
@@ -28,14 +29,14 @@ var DEFAULTS = {
   userName: "Developer"
 };
 function ensureDir() {
-  if (!fs3.existsSync(DOMINUS_DIR)) {
-    fs3.mkdirSync(DOMINUS_DIR, { recursive: true });
+  if (!fs4.existsSync(DOMINUS_DIR)) {
+    fs4.mkdirSync(DOMINUS_DIR, { recursive: true });
   }
 }
 function readJson(filePath, defaults) {
   try {
-    if (fs3.existsSync(filePath)) {
-      const raw = fs3.readFileSync(filePath, "utf-8");
+    if (fs4.existsSync(filePath)) {
+      const raw = fs4.readFileSync(filePath, "utf-8");
       return { ...defaults, ...JSON.parse(raw) };
     }
   } catch {
@@ -76,6 +77,32 @@ var ControllerMsg = {
   SET_ACTIVE_CONNECTION: "controller:set_active_connection"
 };
 var CliMsg = {
+  GET_EXPLORER: "cli:get:explorer",
+  GET_SCRIPT: "cli:get:script",
+  SET_SCRIPT: "cli:set:script",
+  RUN_CODE: "cli:run",
+  GET_PROPERTIES: "cli:get:properties",
+  GET_DESCENDANTS_PROPERTIES: "cli:get:descendants:properties",
+  SET_PROPERTIES: "cli:set:properties",
+  INSERT_INSTANCE: "cli:insert",
+  DELETE_INSTANCE: "cli:delete",
+  GET_SELECTION: "cli:get:selection",
+  SELECT: "cli:select",
+  SEARCH_SCRIPTS: "cli:search:scripts",
+  GET_OUTPUT: "cli:get:output",
+  RUN_TESTS: "cli:run:tests",
+  EXECUTE_RUN_TEST: "cli:test:run",
+  EXECUTE_PLAY_TEST: "cli:test:play",
+  END_TEST: "cli:test:end",
+  BUILD_UI: "cli:build:ui",
+  GET_REFLECTION: "cli:get:reflection",
+  UPLOAD_ASSET: "cli:upload:asset",
+  SERIALIZE_UI: "cli:serialize:ui",
+  MOVE_INSTANCE: "cli:move:instance",
+  UNDO: "cli:undo",
+  REDO: "cli:redo",
+  BULK_SET_PROPERTIES: "cli:bulk:set:properties",
+  FIND_REPLACE_SCRIPTS: "cli:find:replace:scripts",
   V2_GET_TREE: "studio:v2:get_tree",
   V2_INSPECT: "studio:v2:inspect",
   V2_GET_SELECTION: "studio:v2:get_selection",
@@ -118,27 +145,21 @@ var wsMessageSchema = z.object({
 }).strict();
 var TOKEN_FILE = "bridge-token";
 function loadOrCreateBridgeToken() {
-  const tokenPath = path3.join(getDominusDir(), TOKEN_FILE);
+  const tokenPath = path4.join(getDominusDir(), TOKEN_FILE);
   try {
-    const existing = fs3.readFileSync(tokenPath, "utf8").trim();
+    const existing = fs4.readFileSync(tokenPath, "utf8").trim();
     if (existing.length >= 32) return existing;
   } catch {
   }
   const token = crypto.randomBytes(32).toString("base64url");
-  fs3.writeFileSync(tokenPath, `${token}
+  fs4.writeFileSync(tokenPath, `${token}
 `, { encoding: "utf8", mode: 384 });
   try {
-    fs3.chmodSync(tokenPath, 384);
+    fs4.chmodSync(tokenPath, 384);
   } catch {
   }
   return token;
 }
-function tokensEqual(actual, expected) {
-  if (typeof actual !== "string") return false;
-  const actualBuffer = Buffer.from(actual);
-  const expectedBuffer = Buffer.from(expected);
-  return actualBuffer.length === expectedBuffer.length && crypto.timingSafeEqual(actualBuffer, expectedBuffer);
-}
 
 // src/transport/ws-client.ts
 var DominusClient = class extends EventEmitter {
@@ -171,10 +192,14 @@ var DominusClient = class extends EventEmitter {
       }, this.connectTimeoutMs);
       ws.on("open", () => {
         this.ws = ws;
-        ws.send(serializeMessage(createMessage(ControllerMsg.HELLO, {
-          protocolVersion: DOMINUS_PROTOCOL_VERSION,
-          token: this.token
-        })));
+        ws.send(
+          serializeMessage(
+            createMessage(ControllerMsg.HELLO, {
+              protocolVersion: DOMINUS_PROTOCOL_VERSION,
+              token: this.token
+            })
+          )
+        );
       });
       ws.on("message", (raw) => {
         try {
@@ -315,7 +340,11 @@ var DominusClient = class extends EventEmitter {
   sendRequest(type, payload, timeoutMs = 15e3) {
     const target = this.resolveTargetInfo();
     if (!target || !this.activeConnectionId) {
-      return Promise.reject(new Error(this.connections.size > 1 ? "Multiple Studio sessions are connected. Call dominus_select_studio first." : "No authenticated Roblox Studio connection"));
+      return Promise.reject(
+        new Error(
+          this.connections.size > 1 ? "Multiple Studio sessions are connected. Call dominus_select_studio first." : "No authenticated Roblox Studio connection"
+        )
+      );
     }
     const request = createMessage(type, payload);
     const relay = createMessage(ControllerMsg.RELAY, {
@@ -344,10 +373,12 @@ var DominusClient = class extends EventEmitter {
   sendNotification(type, payload) {
     if (!this.activeConnectionId) return;
     const request = createMessage(type, payload);
-    this.sendMessage(createMessage(ControllerMsg.RELAY, {
-      connectionId: this.activeConnectionId,
-      request
-    }));
+    this.sendMessage(
+      createMessage(ControllerMsg.RELAY, {
+        connectionId: this.activeConnectionId,
+        request
+      })
+    );
   }
   isConnected() {
     return this.resolveTargetInfo() !== null;
@@ -386,9 +417,13 @@ var DominusClient = class extends EventEmitter {
       void this.setActiveConnectionId(null);
       return;
     }
-    const matches = [...this.connections.values()].filter((connection) => connection.placeId === placeId);
+    const matches = [...this.connections.values()].filter(
+      (connection) => connection.placeId === placeId
+    );
     if (matches.length !== 1) {
-      throw new Error(matches.length === 0 ? `Place ${placeId} is not connected` : `Place ${placeId} has multiple Studio sessions; select a connectionId instead`);
+      throw new Error(
+        matches.length === 0 ? `Place ${placeId} is not connected` : `Place ${placeId} has multiple Studio sessions; select a connectionId instead`
+      );
     }
     void this.setActiveConnectionId(matches[0].connectionId);
   }
@@ -449,413 +484,74 @@ async function isPortInUse(port) {
     });
   });
 }
-var HANDSHAKE_TIMEOUT_MS = 8e3;
-var RATE_WINDOW_MS = 1e4;
-var RATE_LIMIT = 250;
-var DominusServer = class extends EventEmitter {
-  wss = null;
-  studioClients = /* @__PURE__ */ new Map();
-  wsToConnectionId = /* @__PURE__ */ new Map();
-  controllers = /* @__PURE__ */ new Set();
-  socketRoles = /* @__PURE__ */ new Map();
-  pendingRequests = /* @__PURE__ */ new Map();
-  relayRequests = /* @__PURE__ */ new Map();
-  rateState = /* @__PURE__ */ new Map();
-  token;
-  host;
-  maxPayloadBytes;
-  handshakeTimeoutMs;
-  activeConnectionId = null;
-  port;
-  constructor(port = 18088, options = {}) {
-    super();
-    this.port = port;
-    this.token = options.token ?? loadOrCreateBridgeToken();
-    this.host = options.host ?? "127.0.0.1";
-    this.maxPayloadBytes = options.maxPayloadBytes ?? MAX_MESSAGE_BYTES;
-    this.handshakeTimeoutMs = options.handshakeTimeoutMs ?? HANDSHAKE_TIMEOUT_MS;
-  }
-  start(maxRetries = 0) {
-    return new Promise((resolve, reject) => {
-      const tryPort = (port, attempt) => {
-        const wss = new WebSocketServer({
-          port,
-          host: this.host,
-          maxPayload: this.maxPayloadBytes,
-          perMessageDeflate: false
-        });
-        wss.on("listening", () => {
-          this.wss = wss;
-          this.port = port;
-          wss.on("connection", (ws) => this.handleConnection(ws));
-          this.emit("server:started", { port, host: this.host });
-          resolve();
-        });
-        wss.on("error", (err) => {
-          if (err.code === "EADDRINUSE" && attempt < maxRetries) {
-            wss.close();
-            tryPort(port + 1, attempt + 1);
-            return;
-          }
-          this.emit("server:error", err);
-          reject(err);
-        });
-      };
-      tryPort(this.port, 0);
-    });
-  }
-  handleConnection(ws) {
-    this.socketRoles.set(ws, "unknown");
-    this.rateState.set(ws, { startedAt: Date.now(), count: 0 });
-    const handshakeTimer = setTimeout(() => {
-      if (this.socketRoles.get(ws) === "unknown") {
-        ws.close(1008, "Dominus handshake timed out");
-      }
-    }, this.handshakeTimeoutMs);
-    ws.on("message", (raw) => {
-      try {
-        if (!this.consumeRateBudget(ws) || rawByteLength(raw) > this.maxPayloadBytes) {
-          ws.close(1009, "Dominus message limit exceeded");
-          return;
-        }
-        const msg = parseMessage(raw.toString());
-        const role = this.socketRoles.get(ws) ?? "unknown";
-        if (role === "unknown") {
-          clearTimeout(handshakeTimer);
-          this.handleHandshake(ws, msg);
-        } else if (role === "controller") {
-          this.handleControllerMessage(ws, msg);
-        } else if (role === "studio") {
-          this.handleStudioMessage(ws, msg);
-        }
-      } catch (err) {
-        this.emit("server:error", err);
-        this.sendSafe(ws, createMessage(StudioMsg.AUTH_REJECTED, {
-          error: err instanceof Error ? err.message : String(err)
-        }));
-      }
-    });
-    ws.on("close", () => {
-      clearTimeout(handshakeTimer);
-      this.cleanupSocket(ws);
-    });
-    ws.on("error", (err) => this.emit("server:error", err));
-  }
-  consumeRateBudget(ws) {
-    const now = Date.now();
-    const state = this.rateState.get(ws) ?? { startedAt: now, count: 0 };
-    if (now - state.startedAt >= RATE_WINDOW_MS) {
-      state.startedAt = now;
-      state.count = 0;
-    }
-    state.count += 1;
-    this.rateState.set(ws, state);
-    return state.count <= RATE_LIMIT;
-  }
-  handleHandshake(ws, msg) {
-    if (msg.type === StudioMsg.HELLO) {
-      const hello = validateStudioHello(msg.payload);
-      if (tokensEqual(hello.token, this.token)) {
-        this.authorizeStudio(ws, hello, randomUUID());
-      } else {
-        this.sendSafe(ws, createMessage(StudioMsg.AUTH_REJECTED, {
-          error: "Studio plugin credentials are missing or stale. Run dominus-install-plugin and restart Studio."
-        }));
-        ws.close(1008, "Unauthorized Studio plugin");
-      }
-      return;
-    }
-    if (msg.type === ControllerMsg.HELLO) {
-      const payload = msg.payload;
-      if (payload.protocolVersion !== DOMINUS_PROTOCOL_VERSION || !tokensEqual(payload.token, this.token)) {
-        this.sendSafe(ws, createMessage(StudioMsg.AUTH_REJECTED, { error: "Invalid Dominus controller credentials" }));
-        ws.close(1008, "Unauthorized controller");
-        return;
-      }
-      this.socketRoles.set(ws, "controller");
-      this.controllers.add(ws);
-      this.sendSafe(ws, createMessage(ControllerMsg.WELCOME, {
-        protocolVersion: DOMINUS_PROTOCOL_VERSION,
-        port: this.port,
-        connections: this.listConnections(),
-        activeConnectionId: this.activeConnectionId
-      }));
-      return;
-    }
-    this.sendSafe(ws, createMessage(StudioMsg.AUTH_REJECTED, {
-      error: `Expected ${StudioMsg.HELLO} or ${ControllerMsg.HELLO}`
-    }));
-    ws.close(1008, "Invalid Dominus handshake");
-  }
-  authorizeStudio(ws, hello, connectionId) {
-    const connection = {
-      ws,
-      connectionId,
-      clientId: hello.clientId,
-      connectedAt: Date.now(),
-      studioVersion: hello.studioVersion,
-      placeId: hello.placeId ?? 0,
-      placeName: hello.placeName
-    };
-    this.studioClients.set(connectionId, connection);
-    this.wsToConnectionId.set(ws, connectionId);
-    this.socketRoles.set(ws, "studio");
-    if (!this.activeConnectionId || !this.studioClients.has(this.activeConnectionId)) {
-      this.activeConnectionId = connectionId;
-    }
-    this.sendSafe(ws, createMessage(StudioMsg.AUTHENTICATED, {
-      protocolVersion: DOMINUS_PROTOCOL_VERSION,
-      connectionId,
-      token: this.token
-    }));
-    const info = this.toPlaceInfo(connection);
-    this.emit("studio:connected", info);
-    this.broadcastToControllers(StudioMsg.CONNECTED, info);
-    this.broadcastTargetState();
-    return connection;
-  }
-  handleControllerMessage(controllerWs, msg) {
-    if (msg.type === ControllerMsg.RELAY) {
-      const payload = msg.payload;
-      const request = parseMessage(JSON.stringify(payload.request));
-      const target = this.resolveConnection(typeof payload.connectionId === "string" ? payload.connectionId : null);
-      if (!target) {
-        this.sendResponse(controllerWs, request.id, { error: this.getTargetError() });
-        return;
-      }
-      this.relayRequests.set(request.id, { controllerWs, targetWs: target.ws });
-      this.sendSafe(target.ws, request);
-      return;
-    }
-    if (msg.type === ControllerMsg.SET_ACTIVE_CONNECTION) {
-      const payload = msg.payload;
-      const connectionId = typeof payload.connectionId === "string" ? payload.connectionId : null;
-      if (connectionId && !this.studioClients.has(connectionId)) {
-        this.sendResponse(controllerWs, msg.id, { success: false, error: `Studio connection ${connectionId} is not connected` });
-        return;
-      }
-      this.sendResponse(controllerWs, msg.id, { success: true, connectionId });
-      return;
-    }
-    this.sendResponse(controllerWs, msg.id, { error: `Unsupported controller message: ${msg.type}` });
-  }
-  handleStudioMessage(ws, msg) {
-    if (msg.type === StudioMsg.RESPONSE) {
-      const relay = this.relayRequests.get(msg.id);
-      if (relay) {
-        if (relay.targetWs !== ws) {
-          this.emit("server:error", new Error(`Ignored relayed response ${msg.id} from the wrong Studio session`));
-          return;
-        }
-        this.sendSafe(relay.controllerWs, 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(`Ignored response ${msg.id} from the wrong Studio session`));
-          return;
-        }
-        clearTimeout(pending.timer);
-        this.pendingRequests.delete(msg.id);
-        pending.resolve(msg);
-      }
-      return;
-    }
-    this.emit(msg.type, msg.payload);
-    this.emit("message", msg);
+
+// src/transport/daemon-launcher.ts
+function resolveDaemonPath() {
+  const besideEntry = fileURLToPath(new URL("./bridge-daemon.js", import.meta.url));
+  if (fs4.existsSync(besideEntry)) return besideEntry;
+  const projectBuild = path4.resolve(
+    path4.dirname(fileURLToPath(import.meta.url)),
+    "../../dist/bridge-daemon.js"
+  );
+  if (fs4.existsSync(projectBuild)) return projectBuild;
+  throw new Error("Dominus bridge daemon is missing. Reinstall or rebuild dominus-cli.");
+}
+function launchBridgeDaemon(port, daemonPath = resolveDaemonPath()) {
+  const child = spawn(process.execPath, [daemonPath], {
+    detached: true,
+    env: { ...process.env, DOMINUS_BRIDGE_PORT: String(port) },
+    stdio: "ignore",
+    windowsHide: true
+  });
+  child.unref();
+}
+async function connectController(port, timeoutMs, token) {
+  const client = new DominusClient(port, { connectTimeoutMs: timeoutMs, token });
+  try {
+    await client.connect();
+    return client;
+  } catch (error) {
+    await client.stop().catch(() => void 0);
+    throw error;
   }
-  cleanupSocket(ws) {
-    const role = this.socketRoles.get(ws);
-    this.socketRoles.delete(ws);
-    this.rateState.delete(ws);
-    if (role === "controller") {
-      this.controllers.delete(ws);
-      for (const [id, relay] of this.relayRequests) {
-        if (relay.controllerWs === ws) this.relayRequests.delete(id);
-      }
-      return;
-    }
-    const connectionId = this.wsToConnectionId.get(ws);
-    if (!connectionId) return;
-    const connection = this.studioClients.get(connectionId);
-    this.wsToConnectionId.delete(ws);
-    this.studioClients.delete(connectionId);
-    for (const [id, pending] of this.pendingRequests) {
-      if (pending.targetWs === ws) {
-        clearTimeout(pending.timer);
-        pending.reject(new Error(`Studio disconnected (${connectionId})`));
-        this.pendingRequests.delete(id);
-      }
-    }
-    for (const [id, relay] of this.relayRequests) {
-      if (relay.targetWs === ws) {
-        this.sendResponse(relay.controllerWs, id, { error: `Studio disconnected (${connectionId})` });
-        this.relayRequests.delete(id);
-      }
-    }
-    if (this.activeConnectionId === connectionId) {
-      this.activeConnectionId = this.studioClients.size === 1 ? this.studioClients.keys().next().value ?? null : null;
-    }
-    const info = connection ? this.toPlaceInfo(connection) : { connectionId };
-    this.emit("studio:disconnected", info);
-    this.broadcastToControllers(StudioMsg.DISCONNECTED, info);
-    this.broadcastTargetState();
-  }
-  resolveConnection(connectionId = this.activeConnectionId) {
-    if (connectionId) {
-      const connection = this.studioClients.get(connectionId);
-      return connection?.ws.readyState === WebSocket.OPEN ? connection : null;
-    }
-    if (this.studioClients.size === 1) {
-      const connection = this.studioClients.values().next().value;
-      return connection?.ws.readyState === WebSocket.OPEN ? connection : null;
+}
+async function ensureBridgeDaemon(port, options = {}) {
+  const attempts = options.attempts ?? 30;
+  const connectTimeoutMs = options.connectTimeoutMs ?? 750;
+  const retryDelayMs = options.retryDelayMs ?? 100;
+  try {
+    return await connectController(port, connectTimeoutMs, options.token);
+  } catch (initialError) {
+    if (await isPortInUse(port)) {
+      throw new Error(
+        `Port ${port} is occupied by a process that is not this Dominus bridge: ${formatError(initialError)}`
+      );
     }
-    return null;
   }
-  getTargetError() {
-    if (this.studioClients.size === 0) return "No authenticated Roblox Studio connection";
-    if (this.activeConnectionId) return `Studio connection ${this.activeConnectionId} is unavailable`;
-    return "Multiple Studio sessions are connected. Call dominus_select_studio with a connectionId.";
-  }
-  toPlaceInfo(connection) {
-    return {
-      placeId: connection.placeId ?? 0,
-      connectionId: connection.connectionId,
-      clientId: connection.clientId,
-      placeName: connection.placeName,
-      studioVersion: connection.studioVersion,
-      connectedAt: connection.connectedAt,
-      active: connection.connectionId === this.activeConnectionId
-    };
-  }
-  broadcastToControllers(type, payload) {
-    const message = createMessage(type, payload);
-    for (const controller of this.controllers) this.sendSafe(controller, message);
-  }
-  broadcastTargetState() {
-    this.broadcastToControllers(ControllerMsg.TARGET_STATE, {
-      connections: this.listConnections(),
-      defaultActiveConnectionId: this.activeConnectionId
-    });
-  }
-  sendResponse(ws, id, payload) {
-    this.sendSafe(ws, { id, type: StudioMsg.RESPONSE, payload, ts: Date.now() });
-  }
-  sendSafe(ws, message) {
-    if (ws.readyState !== WebSocket.OPEN) return;
+  const launch = options.launch ?? ((targetPort) => launchBridgeDaemon(targetPort, options.daemonPath));
+  launch(port);
+  let lastError;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
     try {
-      ws.send(serializeMessage(message));
-    } catch (err) {
-      this.emit("server:error", err);
+      return await connectController(port, connectTimeoutMs, options.token);
+    } catch (error) {
+      lastError = error;
     }
   }
-  sendRequest(type, payload, timeoutMs = 15e3) {
-    return new Promise((resolve, reject) => {
-      const target = this.resolveConnection();
-      if (!target) {
-        reject(new Error(this.getTargetError()));
-        return;
-      }
-      const message = createMessage(type, payload);
-      const timer = setTimeout(() => {
-        this.pendingRequests.delete(message.id);
-        reject(new Error(`Studio request timed out: ${type}`));
-      }, timeoutMs);
-      this.pendingRequests.set(message.id, {
-        resolve,
-        reject,
-        timer,
-        targetWs: target.ws
-      });
-      this.sendSafe(target.ws, message);
-    });
-  }
-  sendNotification(type, payload) {
-    const target = this.resolveConnection();
-    if (target) this.sendSafe(target.ws, createMessage(type, payload));
-  }
-  isConnected() {
-    return this.resolveConnection() !== null;
-  }
-  getConnectionInfo() {
-    return this.resolveConnection();
-  }
-  listConnections() {
-    return [...this.studioClients.values()].filter(({ ws }) => ws.readyState === WebSocket.OPEN).map((connection) => this.toPlaceInfo(connection));
-  }
-  getActiveConnectionId() {
-    return this.activeConnectionId;
-  }
-  async setActiveConnectionId(connectionId) {
-    if (connectionId && !this.studioClients.has(connectionId)) {
-      throw new Error(`Studio connection ${connectionId} is not connected`);
-    }
-    this.activeConnectionId = connectionId;
-    this.broadcastTargetState();
-  }
-  getActivePlaceId() {
-    return this.resolveConnection()?.placeId ?? 0;
-  }
-  setActivePlaceId(placeId) {
-    if (placeId === 0) {
-      this.activeConnectionId = null;
-      return;
-    }
-    const matches = [...this.studioClients.values()].filter((connection) => connection.placeId === placeId);
-    if (matches.length !== 1) {
-      throw new Error(matches.length === 0 ? `Place ${placeId} is not connected` : `Place ${placeId} has multiple Studio sessions; select a connectionId instead`);
-    }
-    this.activeConnectionId = matches[0].connectionId;
-  }
-  getPort() {
-    return this.port;
-  }
-  stop() {
-    return new Promise((resolve) => {
-      for (const pending of this.pendingRequests.values()) {
-        clearTimeout(pending.timer);
-        pending.reject(new Error("Dominus bridge is shutting down"));
-      }
-      this.pendingRequests.clear();
-      this.relayRequests.clear();
-      for (const ws of this.socketRoles.keys()) ws.close(1001, "Dominus bridge shutdown");
-      this.studioClients.clear();
-      this.controllers.clear();
-      this.socketRoles.clear();
-      this.wsToConnectionId.clear();
-      if (this.wss) this.wss.close(() => resolve());
-      else resolve();
-    });
-  }
-};
-function validateStudioHello(payload) {
-  if (!payload || typeof payload !== "object") throw new Error("Invalid Studio hello payload");
-  const hello = payload;
-  if (hello.protocolVersion !== DOMINUS_PROTOCOL_VERSION) {
-    throw new Error(`Studio plugin protocol ${hello.protocolVersion ?? "unknown"} is incompatible; expected ${DOMINUS_PROTOCOL_VERSION}`);
-  }
-  if (typeof hello.clientId !== "string" || hello.clientId.length < 8 || hello.clientId.length > 128) {
-    throw new Error("Studio hello is missing a valid clientId");
-  }
-  if (typeof hello.studioVersion !== "string" || hello.studioVersion.length > 128) {
-    throw new Error("Studio hello is missing studioVersion");
-  }
-  if (hello.placeName && hello.placeName.length > 256) throw new Error("Studio placeName is too long");
-  return hello;
+  throw new Error(
+    `Dominus could not start its local Studio bridge on port ${port}: ${formatError(lastError)}`
+  );
 }
-function rawByteLength(raw) {
-  if (typeof raw === "string") return Buffer.byteLength(raw);
-  if (Array.isArray(raw)) return raw.reduce((total, item) => total + item.byteLength, 0);
-  return raw.byteLength;
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error ?? "unknown error");
 }
 
 // src/mcp/instructions.ts
 var DOMINUS_MCP_INSTRUCTIONS = `Dominus 2 is a Roblox Studio engineering MCP server.
 
 Required workflow for Studio changes:
-1. Call dominus_status and select the intended Studio connection when more than one is open.
+1. Call dominus_status. If Studio is disconnected, ask the user to run dominus-install-plugin only when the Studio Output reports an authentication failure. Select the intended authenticated Studio connection when more than one window is open.
 2. Inspect the relevant tree, selection, instances, scripts, and Roblox API references before editing.
 3. Form a short plan with explicit acceptance checks.
 4. Use stable instance refs returned by Dominus. Prefer instanceId; retain pathSegments as fallback context.
@@ -863,6 +559,8 @@ Required workflow for Studio changes:
 6. Read the affected instances back and compare exact values, hierarchy, and source revisions.
 7. Run an appropriate Studio test when behavior changed. Report verification evidence and any remaining uncertainty.
 
+For broad tasks with independent Studio branches, prefer run_parallel_task when the MCP client supports Sampling. Dominus partitions immediate child scopes, runs proposal-only workers concurrently, rejects unknown refs and overlapping writes, applies only the coordinator-approved atomic plan, and reads the result back. Use the normal workflow when Sampling is unavailable or the task is a simple edit.
+
 Safety rules:
 - Never invent instance IDs or Roblox API members.
 - Do not retry a failed write unchanged. Inspect the error and current state first.
@@ -873,30 +571,47 @@ Safety rules:
 
 // src/mcp/resources.ts
 function registerDominusResources(server, bridge) {
-  server.registerResource("dominus-status", "dominus://status", {
-    title: "Dominus 2 Studio Status",
-    description: "Current authenticated Roblox Studio sessions and selected target.",
-    mimeType: "application/json"
-  }, async (uri) => ({
-    contents: [{
-      uri: uri.href,
-      mimeType: "application/json",
-      text: JSON.stringify({
-        protocolVersion: 2,
-        activeConnectionId: bridge.getActiveConnectionId(),
-        connections: bridge.listConnections()
-      }, null, 2)
-    }]
-  }));
-  server.registerPrompt("dominus-workflow", {
-    title: "Dominus 2 Engineering Workflow",
-    description: "Inspect, plan, apply, verify, and test a Roblox Studio change safely."
-  }, async () => ({
-    messages: [{
-      role: "user",
-      content: { type: "text", text: DOMINUS_MCP_INSTRUCTIONS }
-    }]
-  }));
+  server.registerResource(
+    "dominus-status",
+    "dominus://status",
+    {
+      title: "Dominus 2 Studio Status",
+      description: "Current authenticated Roblox Studio sessions and selected target.",
+      mimeType: "application/json"
+    },
+    async (uri) => ({
+      contents: [
+        {
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify(
+            {
+              protocolVersion: 2,
+              activeConnectionId: bridge.getActiveConnectionId(),
+              connections: bridge.listConnections()
+            },
+            null,
+            2
+          )
+        }
+      ]
+    })
+  );
+  server.registerPrompt(
+    "dominus-workflow",
+    {
+      title: "Dominus 2 Engineering Workflow",
+      description: "Inspect, plan, apply, verify, and test a Roblox Studio change safely."
+    },
+    async () => ({
+      messages: [
+        {
+          role: "user",
+          content: { type: "text", text: DOMINUS_MCP_INSTRUCTIONS }
+        }
+      ]
+    })
+  );
 }
 
 // src/mcp/result.ts
@@ -930,55 +645,77 @@ var toolOutputSchema = {
 };
 async function callStudio(bridge, command, payload, timeoutMs = 15e3) {
   try {
-    const response = await bridge.sendRequest(command, payload, timeoutMs);
-    const result = response.payload;
-    if (!result || typeof result !== "object") return failure("Studio returned an invalid response");
-    if (result.success === false || typeof result.error === "string") {
-      return failure(result.error ?? "Studio command failed", result);
-    }
+    const result = await requestStudio(bridge, command, payload, timeoutMs);
     return success(result);
   } catch (err) {
     return failure(err);
   }
 }
+async function requestStudio(bridge, command, payload, timeoutMs = 15e3) {
+  const response = await bridge.sendRequest(command, payload, timeoutMs);
+  const result = response.payload;
+  if (!result || typeof result !== "object") throw new Error("Studio returned an invalid response");
+  if (result.success === false || typeof result.error === "string") {
+    throw new Error(typeof result.error === "string" ? result.error : "Studio command failed");
+  }
+  return result;
+}
 function ref(value) {
   return value;
 }
 
 // src/mcp/tools/connections.ts
 function registerConnectionTools(server, bridge) {
-  server.registerTool("dominus_status", {
-    title: "Dominus Studio Status",
-    description: "List authenticated Roblox Studio sessions, the active target, and bridge health. Call this before Studio work.",
-    inputSchema: {},
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
-  }, async () => {
-    try {
-      return success({
-        protocolVersion: 2,
-        port: bridge.getPort(),
-        activeConnectionId: bridge.getActiveConnectionId(),
-        connections: bridge.listConnections()
-      });
-    } catch (err) {
-      return failure(err);
+  server.registerTool(
+    "dominus_status",
+    {
+      title: "Dominus Studio Status",
+      description: "List authenticated Roblox Studio sessions, the active target, and bridge health. Call this before Studio work.",
+      inputSchema: {},
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async () => {
+      try {
+        return success({
+          protocolVersion: 2,
+          port: bridge.getPort(),
+          activeConnectionId: bridge.getActiveConnectionId(),
+          connections: bridge.listConnections()
+        });
+      } catch (err) {
+        return failure(err);
+      }
     }
-  });
-  server.registerTool("dominus_select_studio", {
-    title: "Select Studio Session",
-    description: "Choose the exact Studio connection targeted by subsequent tools. Uses connectionId, not placeId, so duplicate windows are safe.",
-    inputSchema: { connectionId: z.string().uuid().nullable() },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
-  }, async ({ connectionId }) => {
-    try {
-      await bridge.setActiveConnectionId(connectionId);
-      return success({ activeConnectionId: bridge.getActiveConnectionId() });
-    } catch (err) {
-      return failure(err);
+  );
+  server.registerTool(
+    "dominus_select_studio",
+    {
+      title: "Select Studio Session",
+      description: "Choose the exact Studio connection targeted by subsequent tools. Uses connectionId, not placeId, so duplicate windows are safe.",
+      inputSchema: { connectionId: z.string().uuid().nullable() },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ connectionId }) => {
+      try {
+        await bridge.setActiveConnectionId(connectionId);
+        return success({ activeConnectionId: bridge.getActiveConnectionId() });
+      } catch (err) {
+        return failure(err);
+      }
     }
-  });
+  );
 }
 var GITHUB_RAW_BASE = "https://raw.githubusercontent.com/Roblox/creator-docs/main/content/en-us/reference/engine";
 var GITHUB_TREE_URL = "https://api.github.com/repos/Roblox/creator-docs/git/trees/main?recursive=1";
@@ -1097,10 +834,10 @@ async function readReferenceYaml(name, kind, opts) {
   const folder = KIND_FOLDERS[kind];
   const fileName = `${name}.yaml`;
   if (localRoot) {
-    const localPath = path3.join(localRoot, folder, fileName);
-    if (fs3.existsSync(localPath)) {
+    const localPath = path4.join(localRoot, folder, fileName);
+    if (fs4.existsSync(localPath)) {
       return {
-        content: fs3.readFileSync(localPath, "utf-8"),
+        content: fs4.readFileSync(localPath, "utf-8"),
         sourceUrl: toCreatorDocsUrl(kind, name)
       };
     }
@@ -1120,11 +857,11 @@ async function listReferenceEntries(opts) {
   if (localRoot) {
     const entries = [];
     for (const [kind, folder] of Object.entries(KIND_FOLDERS)) {
-      const dir = path3.join(localRoot, folder);
-      if (!fs3.existsSync(dir)) continue;
-      for (const file of fs3.readdirSync(dir)) {
+      const dir = path4.join(localRoot, folder);
+      if (!fs4.existsSync(dir)) continue;
+      for (const file of fs4.readdirSync(dir)) {
         if (!file.endsWith(".yaml")) continue;
-        const name = path3.basename(file, ".yaml");
+        const name = path4.basename(file, ".yaml");
         entries.push({ name, kind, score: 0, sourceUrl: toCreatorDocsUrl(kind, name) });
       }
     }
@@ -1137,7 +874,7 @@ async function listReferenceEntries(opts) {
     const [folder, file] = rest.split("/");
     const kind = folderToKind(folder);
     if (!kind || !file) return [];
-    const name = path3.basename(file, ".yaml");
+    const name = path4.basename(file, ".yaml");
     return [{ name, kind, score: 0, sourceUrl: toCreatorDocsUrl(kind, name) }];
   });
 }
@@ -1157,19 +894,19 @@ function resolveDocsRoot(explicitRoot) {
   const candidates = [
     explicitRoot,
     process.env.ROBLOX_CREATOR_DOCS_PATH,
-    path3.join(process.cwd(), ".tmp", "creator-docs")
+    path4.join(process.cwd(), ".tmp", "creator-docs")
   ].filter(Boolean);
   for (const candidate of candidates) {
     const normalized = normalizeDocsRoot(candidate);
-    if (normalized && fs3.existsSync(normalized)) return normalized;
+    if (normalized && fs4.existsSync(normalized)) return normalized;
   }
   return null;
 }
 function normalizeDocsRoot(root) {
-  const engineRoot = path3.join(root, "content", "en-us", "reference", "engine");
-  if (fs3.existsSync(engineRoot)) return engineRoot;
-  const directClasses = path3.join(root, "classes");
-  if (fs3.existsSync(directClasses)) return root;
+  const engineRoot = path4.join(root, "content", "en-us", "reference", "engine");
+  if (fs4.existsSync(engineRoot)) return engineRoot;
+  const directClasses = path4.join(root, "classes");
+  if (fs4.existsSync(directClasses)) return root;
   return null;
 }
 function normalizeLookupName(name) {
@@ -1401,57 +1138,834 @@ function escapeRegExp(value) {
 // src/mcp/tools/docs.ts
 var kindSchema = z.enum(["any", "class", "datatype", "enum", "global", "library"]);
 function registerDocsTools(server) {
-  server.registerTool("roblox_search_api", {
-    title: "Search Roblox API",
-    description: "Search the official Roblox Creator Docs engine API mirror by exact or partial class, datatype, enum, global, or library name.",
-    inputSchema: {
-      query: z.string().min(1).max(100),
-      kind: kindSchema.optional().default("any"),
-      limit: z.number().int().min(1).max(25).optional().default(10)
+  server.registerTool(
+    "roblox_search_api",
+    {
+      title: "Search Roblox API",
+      description: "Search the official Roblox Creator Docs engine API mirror by exact or partial class, datatype, enum, global, or library name.",
+      inputSchema: {
+        query: z.string().min(1).max(100),
+        kind: kindSchema.optional().default("any"),
+        limit: z.number().int().min(1).max(25).optional().default(10)
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
     },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
-  }, async ({ query, kind, limit }) => {
-    try {
-      return success({ results: await searchRobloxApi(query, { kind, limit }) });
-    } catch (err) {
-      return failure(err);
+    async ({ query, kind, limit }) => {
+      try {
+        return success({ results: await searchRobloxApi(query, { kind, limit }) });
+      } catch (err) {
+        return failure(err);
+      }
     }
+  );
+  server.registerTool(
+    "roblox_get_api",
+    {
+      title: "Get Roblox API Reference",
+      description: "Read an official Roblox engine API reference including members, types, security, thread safety, inheritance, and source URL.",
+      inputSchema: {
+        name: z.string().min(1).max(100),
+        kind: kindSchema.optional().default("any"),
+        includeInherited: z.boolean().optional().default(true)
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async ({ name, kind, includeInherited }) => {
+      try {
+        const reference = await getRobloxApiReference(name, { kind, includeInherited });
+        return success({ reference });
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+}
+var propertiesSchema = z.record(z.unknown()).refine(
+  (properties) => Object.keys(properties).length <= 100 && !Object.keys(properties).some((name) => ["Parent", "ClassName", "Source"].includes(name)),
+  "At most 100 properties are allowed; Parent, ClassName, and Source require dedicated operations"
+);
+var mutationOperationSchema = z.discriminatedUnion("op", [
+  z.object({
+    op: z.literal("setProperties"),
+    target: instanceRefSchema,
+    properties: propertiesSchema
+  }),
+  z.object({
+    op: z.literal("create"),
+    parent: instanceRefSchema,
+    className: z.string().min(1).max(100),
+    name: z.string().min(1).max(256),
+    properties: propertiesSchema.optional()
+  }),
+  z.object({
+    op: z.literal("move"),
+    target: instanceRefSchema,
+    parent: instanceRefSchema
+  })
+]);
+var workerProposalSchema = z.object({
+  workerId: z.string().min(1).max(64),
+  summary: z.string().min(1).max(4e3),
+  evidence: z.array(
+    z.object({
+      source: z.string().min(1).max(500),
+      summary: z.string().min(1).max(2e3)
+    })
+  ).max(30).default([]),
+  operations: z.array(mutationOperationSchema).max(50).default([]),
+  risks: z.array(z.string().max(1e3)).max(30).default([]),
+  verificationSuggestions: z.array(z.string().max(1e3)).max(30).default([])
+});
+var coordinatorDecisionSchema = z.object({
+  summary: z.string().min(1).max(4e3),
+  acceptedWorkerIds: z.array(z.string()).max(5),
+  rejected: z.array(
+    z.object({
+      workerId: z.string(),
+      reason: z.string().min(1).max(2e3)
+    })
+  ).max(5).default([]),
+  operationOrder: z.array(
+    z.object({
+      workerId: z.string(),
+      operationIndex: z.number().int().min(0).max(49)
+    })
+  ).max(100),
+  verificationChecks: z.array(z.string().max(1e3)).max(50).default([])
+});
+function registerParallelTaskTool(server, bridge) {
+  server.registerTool(
+    "run_parallel_task",
+    {
+      title: "Run Coordinated Parallel Studio Task",
+      description: "Partition a broad Studio goal into non-overlapping scopes, run proposal-only workers concurrently through MCP Sampling, reject unsafe or conflicting proposals, atomically apply coordinator-approved writes, and verify the result.",
+      inputSchema: {
+        goal: z.string().min(1).max(2e4),
+        root: instanceRefSchema.optional(),
+        rootPath: z.string().min(1).max(2e3).optional(),
+        maxWorkers: z.number().int().min(1).max(5).optional().default(3),
+        constraints: z.string().max(1e4).optional(),
+        taskType: z.string().max(100).optional(),
+        dryRun: z.boolean().optional().default(false)
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({ goal, root, rootPath, maxWorkers, constraints, taskType, dryRun }) => {
+      try {
+        const capabilities = server.server.getClientCapabilities();
+        if (!capabilities?.sampling) {
+          return failure(
+            "run_parallel_task requires an MCP client that supports Sampling. Use the normal Dominus inspect-plan-apply workflow with this client.",
+            { requiredCapability: "sampling" }
+          );
+        }
+        const rootRef = root ?? {
+          pathSegments: parallelRootPathToSegments(rootPath ?? "Workspace")
+        };
+        const tree = await getTree(bridge, rootRef, 5, 1500);
+        const rootNode = tree.roots[0];
+        if (!rootNode) return failure("The requested root did not return a Studio tree");
+        if (tree.truncated) {
+          return failure(
+            "The requested root exceeded the parallel evidence limit. Narrow root/rootPath so workers receive a complete hierarchy.",
+            { nodeCount: tree.nodeCount, maxNodes: 1500 }
+          );
+        }
+        const assignments = createAssignments(goal, rootNode, maxWorkers, constraints, taskType);
+        emit(server, "multi_agent_start", { goal, workerCount: assignments.length });
+        const settled = await Promise.allSettled(
+          assignments.map(async (assignment) => {
+            emit(server, "multi_agent_worker_start", {
+              workerId: assignment.id,
+              role: assignment.role,
+              scopes: assignment.ownedScopes
+            });
+            const result = await runWorker(server, bridge, goal, assignment, constraints, taskType);
+            emit(server, "multi_agent_worker_done", {
+              workerId: assignment.id,
+              summary: result.proposal?.summary ?? result.error ?? "Worker failed",
+              proposedOperationCount: result.proposal?.operations.length ?? 0
+            });
+            return result;
+          })
+        );
+        const workerResults = settled.map(
+          (result, index) => result.status === "fulfilled" ? result.value : { assignment: assignments[index], error: toErrorMessage(result.reason) }
+        );
+        const validated = validateWorkerResults(workerResults);
+        const conflictChecked = rejectProposalConflicts(validated.accepted);
+        const accepted = conflictChecked.accepted;
+        const rejected = [...validated.rejected, ...conflictChecked.rejected];
+        for (const item of accepted) {
+          emit(server, "multi_agent_proposal", {
+            workerId: item.assignment.id,
+            accepted: true,
+            operationCount: item.proposal.operations.length
+          });
+        }
+        for (const item of rejected) {
+          emit(server, "multi_agent_proposal", {
+            workerId: item.workerId,
+            accepted: false,
+            reason: item.reason
+          });
+        }
+        const decision = accepted.length > 0 ? await runCoordinator(server, goal, accepted, rejected, constraints) : emptyDecision(rejected);
+        const finalPlan = buildFinalPlan(decision, accepted, rejected);
+        if (finalPlan.operations.length > 100) {
+          return failure("Coordinator plan exceeds the 100-operation atomic limit", {
+            operationCount: finalPlan.operations.length
+          });
+        }
+        emit(server, "multi_agent_decision", {
+          acceptedCount: finalPlan.acceptedWorkerIds.length,
+          rejectedCount: finalPlan.rejected.length,
+          finalOperationCount: finalPlan.operations.length
+        });
+        let applied = null;
+        let verification = null;
+        let repairApplied = false;
+        if (!dryRun && finalPlan.operations.length > 0) {
+          emit(server, "multi_agent_apply_start", { operationCount: finalPlan.operations.length });
+          applied = await requestStudio(
+            bridge,
+            CliMsg.V2_APPLY,
+            { operations: finalPlan.operations },
+            12e4
+          );
+          verification = await verifyPlan(bridge, rootRef, rootNode, finalPlan.operations);
+          if (!verification.passed) {
+            const repairOperations = findRepairOperations(
+              finalPlan.operations,
+              verification,
+              rootNode
+            );
+            if (repairOperations.length > 0) {
+              await requestStudio(
+                bridge,
+                CliMsg.V2_APPLY,
+                { operations: repairOperations },
+                12e4
+              );
+              repairApplied = true;
+              verification = await verifyPlan(bridge, rootRef, rootNode, finalPlan.operations);
+            }
+          }
+          emit(server, "multi_agent_apply_done", {
+            appliedCount: finalPlan.operations.length,
+            verificationPassed: verification.passed,
+            repairApplied
+          });
+        } else {
+          verification = await verifyPlan(bridge, rootRef, rootNode, []);
+        }
+        return success({
+          goal,
+          root: rootRef,
+          dryRun,
+          assignments: assignments.map(publicAssignment),
+          workers: workerResults.map(publicWorkerResult),
+          decision: {
+            summary: decision.summary,
+            acceptedWorkerIds: finalPlan.acceptedWorkerIds,
+            rejected: finalPlan.rejected,
+            verificationChecks: decision.verificationChecks
+          },
+          finalOperations: finalPlan.operations,
+          applied,
+          repairApplied,
+          verification
+        });
+      } catch (err) {
+        return failure(err);
+      }
+    }
+  );
+}
+async function getTree(bridge, root, maxDepth, maxNodes) {
+  const result = await requestStudio(bridge, CliMsg.V2_GET_TREE, { root, maxDepth, maxNodes });
+  return {
+    roots: Array.isArray(result.roots) ? result.roots : [],
+    nodeCount: typeof result.nodeCount === "number" ? result.nodeCount : 0,
+    truncated: result.truncated === true
+  };
+}
+function createAssignments(goal, root, maxWorkers, constraints, taskType) {
+  const candidates = root.children?.length ? root.children : [root];
+  const workerCount = Math.max(1, Math.min(maxWorkers, candidates.length));
+  const groups = Array.from({ length: workerCount }, () => []);
+  candidates.forEach((node, index) => groups[index % workerCount].push(node));
+  return groups.map((scopeNodes, index) => {
+    const ownedScopes = scopeNodes.map((node) => node.ref);
+    const knownRefKeys = /* @__PURE__ */ new Set();
+    scopeNodes.forEach((node) => collectRefKeys(node, knownRefKeys));
+    return {
+      id: `worker-${index + 1}`,
+      role: `${taskType ?? "general"} scope analyst ${index + 1}`,
+      objective: `Inspect the assigned Studio branches and propose the smallest changes that advance: ${goal}`,
+      ownedScopes,
+      acceptanceCriteria: [
+        "Every referenced existing instance must come from the supplied evidence.",
+        "Every proposed mutation must remain inside an owned scope.",
+        "Do not propose deletion, arbitrary code execution, or script replacement.",
+        constraints?.trim() || "Preserve unrelated instances and behavior."
+      ],
+      scopeNodes,
+      knownRefKeys
+    };
   });
-  server.registerTool("roblox_get_api", {
-    title: "Get Roblox API Reference",
-    description: "Read an official Roblox engine API reference including members, types, security, thread safety, inheritance, and source URL.",
-    inputSchema: {
-      name: z.string().min(1).max(100),
-      kind: kindSchema.optional().default("any"),
-      includeInherited: z.boolean().optional().default(true)
+}
+async function runWorker(server, bridge, goal, assignment, constraints, taskType) {
+  try {
+    const studioInspection = await inspectScopeRoots(bridge, assignment.ownedScopes);
+    const response = await server.server.createMessage(
+      {
+        systemPrompt: [
+          "You are a read-only Dominus worker. Inspect only the Studio evidence in the request.",
+          "You cannot write to Studio. Return one strict JSON WorkerProposal and no Markdown.",
+          "Only propose setProperties, create, or move operations using exact instance refs copied from evidence.",
+          "Never invent instanceId values. Never propose delete, script edits, or arbitrary execution."
+        ].join(" "),
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  schema: {
+                    workerId: assignment.id,
+                    summary: "string",
+                    evidence: [{ source: "string", summary: "string" }],
+                    operations: [
+                      {
+                        op: "setProperties",
+                        target: { instanceId: "uuid", pathSegments: ["..."] },
+                        properties: {}
+                      },
+                      {
+                        op: "create",
+                        parent: { instanceId: "uuid", pathSegments: ["..."] },
+                        className: "Part",
+                        name: "Name",
+                        properties: {}
+                      },
+                      {
+                        op: "move",
+                        target: { instanceId: "uuid", pathSegments: ["..."] },
+                        parent: { instanceId: "uuid", pathSegments: ["..."] }
+                      }
+                    ],
+                    risks: ["string"],
+                    verificationSuggestions: ["string"]
+                  },
+                  globalGoal: goal,
+                  taskType: taskType ?? "general",
+                  constraints: constraints ?? "",
+                  assignment: publicAssignment(assignment),
+                  studioEvidence: {
+                    hierarchy: assignment.scopeNodes,
+                    typedRootInspection: studioInspection
+                  }
+                },
+                null,
+                2
+              )
+            }
+          }
+        ],
+        maxTokens: 5e3,
+        temperature: 0.2,
+        modelPreferences: {
+          intelligencePriority: 0.9,
+          speedPriority: 0.3,
+          costPriority: 0.2
+        }
+      },
+      { timeout: 12e4 }
+    );
+    const proposal = workerProposalSchema.parse(parseJson(extractSamplingText(response.content)));
+    return { assignment, proposal };
+  } catch (err) {
+    return { assignment, error: toErrorMessage(err) };
+  }
+}
+async function inspectScopeRoots(bridge, targets) {
+  const results = [];
+  for (let offset = 0; offset < targets.length; offset += 20) {
+    const inspected = await requestStudio(bridge, CliMsg.V2_INSPECT, {
+      targets: targets.slice(offset, offset + 20),
+      compact: true
+    });
+    if (Array.isArray(inspected.results)) {
+      results.push(...inspected.results);
+    }
+  }
+  return results;
+}
+function validateWorkerResults(results) {
+  const accepted = [];
+  const rejected = [];
+  for (const result of results) {
+    if (!result.proposal) {
+      rejected.push({
+        workerId: result.assignment.id,
+        reason: result.error ?? "Worker returned no proposal"
+      });
+      continue;
+    }
+    if (result.proposal.workerId !== result.assignment.id) {
+      rejected.push({
+        workerId: result.assignment.id,
+        reason: `Proposal workerId ${result.proposal.workerId} did not match its assignment`,
+        summary: result.proposal.summary
+      });
+      continue;
+    }
+    const errors = validateOperations(result.assignment, result.proposal.operations);
+    if (errors.length > 0) {
+      rejected.push({
+        workerId: result.assignment.id,
+        reason: errors.join("; "),
+        summary: result.proposal.summary
+      });
+      continue;
+    }
+    accepted.push({ assignment: result.assignment, proposal: result.proposal });
+  }
+  return { accepted, rejected };
+}
+function validateOperations(assignment, operations) {
+  const errors = [];
+  for (const [index, operation] of operations.entries()) {
+    const refs = operation.op === "create" ? [operation.parent] : operation.op === "move" ? [operation.target, operation.parent] : [operation.target];
+    for (const ref2 of refs) {
+      if (!isKnownParallelRef(ref2, assignment.knownRefKeys)) {
+        errors.push(`Operation ${index} references an instance absent from worker evidence`);
+      } else if (!isParallelRefWithinScopes(ref2, assignment.ownedScopes)) {
+        errors.push(`Operation ${index} targets outside the worker owned scopes`);
+      }
+    }
+  }
+  return errors;
+}
+function rejectProposalConflicts(accepted) {
+  const finalAccepted = [];
+  const rejected = [];
+  const claims = [];
+  for (const item of accepted) {
+    const targets = item.proposal.operations.map(operationTarget);
+    const conflict = claims.find(
+      (claim) => targets.some(
+        (target) => target.path && claim.paths.some((path5) => parallelPathsOverlap(target.path, path5)) || claim.refKeys.includes(target.key)
+      )
+    );
+    if (conflict) {
+      rejected.push({
+        workerId: item.assignment.id,
+        reason: `Proposal overlaps writes owned by ${conflict.workerId}`,
+        summary: item.proposal.summary
+      });
+      continue;
+    }
+    finalAccepted.push(item);
+    claims.push({
+      workerId: item.assignment.id,
+      paths: targets.flatMap((target) => target.path ? [target.path] : []),
+      refKeys: targets.map((target) => target.key)
+    });
+  }
+  return { accepted: finalAccepted, rejected };
+}
+async function runCoordinator(server, goal, accepted, rejected, constraints) {
+  const response = await server.server.createMessage(
+    {
+      systemPrompt: [
+        "You are the Dominus coordinator. Return strict JSON only.",
+        "Workers are proposal-only. Select whole non-conflicting proposals and order their existing operations.",
+        "Do not invent, edit, merge, or partially accept operations. The server will reject any unknown index.",
+        "Prefer the smallest plan that satisfies the goal and preserves unrelated Studio state."
+      ].join(" "),
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: JSON.stringify(
+              {
+                schema: {
+                  summary: "string",
+                  acceptedWorkerIds: ["worker-1"],
+                  rejected: [{ workerId: "worker-2", reason: "string" }],
+                  operationOrder: [{ workerId: "worker-1", operationIndex: 0 }],
+                  verificationChecks: ["string"]
+                },
+                goal,
+                constraints: constraints ?? "",
+                validProposals: accepted.map(({ assignment, proposal }) => ({
+                  workerId: assignment.id,
+                  summary: proposal.summary,
+                  evidence: proposal.evidence,
+                  operations: proposal.operations,
+                  risks: proposal.risks,
+                  verificationSuggestions: proposal.verificationSuggestions
+                })),
+                alreadyRejected: rejected
+              },
+              null,
+              2
+            )
+          }
+        }
+      ],
+      maxTokens: 5e3,
+      temperature: 0.1,
+      modelPreferences: {
+        intelligencePriority: 1,
+        speedPriority: 0.2,
+        costPriority: 0.1
+      }
     },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
-  }, async ({ name, kind, includeInherited }) => {
-    try {
-      const reference = await getRobloxApiReference(name, { kind, includeInherited });
-      return success({ reference });
-    } catch (err) {
-      return failure(err);
+    { timeout: 12e4 }
+  );
+  return coordinatorDecisionSchema.parse(parseJson(extractSamplingText(response.content)));
+}
+function buildFinalPlan(decision, accepted, alreadyRejected) {
+  const byId = new Map(accepted.map((item) => [item.assignment.id, item]));
+  const acceptedIds = [...new Set(decision.acceptedWorkerIds)];
+  for (const workerId of acceptedIds) {
+    if (!byId.has(workerId)) throw new Error(`Coordinator accepted unknown worker ${workerId}`);
+  }
+  const operations = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of decision.operationOrder) {
+    if (!acceptedIds.includes(entry.workerId)) {
+      throw new Error(`Coordinator ordered an operation from unaccepted worker ${entry.workerId}`);
+    }
+    const proposal = byId.get(entry.workerId).proposal;
+    const operation = proposal.operations[entry.operationIndex];
+    if (!operation)
+      throw new Error(
+        `Coordinator selected missing operation ${entry.workerId}:${entry.operationIndex}`
+      );
+    const key = `${entry.workerId}:${entry.operationIndex}`;
+    if (seen.has(key)) throw new Error(`Coordinator selected duplicate operation ${key}`);
+    seen.add(key);
+    operations.push(operation);
+  }
+  for (const workerId of acceptedIds) {
+    const proposal = byId.get(workerId).proposal;
+    for (let index = 0; index < proposal.operations.length; index++) {
+      if (!seen.has(`${workerId}:${index}`)) {
+        throw new Error(
+          `Coordinator partially accepted ${workerId}; operation ${index} was omitted`
+        );
+      }
+    }
+  }
+  const coordinatorReasons = new Map(decision.rejected.map((item) => [item.workerId, item.reason]));
+  const rejected = [...alreadyRejected];
+  for (const item of accepted) {
+    if (!acceptedIds.includes(item.assignment.id)) {
+      rejected.push({
+        workerId: item.assignment.id,
+        reason: coordinatorReasons.get(item.assignment.id) ?? "Coordinator did not accept this proposal",
+        summary: item.proposal.summary
+      });
     }
+  }
+  return { acceptedWorkerIds: acceptedIds, rejected, operations };
+}
+async function verifyPlan(bridge, rootRef, originalRoot, operations) {
+  const tree = await getTree(bridge, rootRef, 12, 5e3);
+  const nodes = flattenTree(tree.roots);
+  const paths = new Set(
+    nodes.flatMap((node) => node.ref.pathSegments ? [pathKey(node.ref.pathSegments)] : [])
+  );
+  const knownPaths = collectInstancePaths(originalRoot);
+  const expectedCreates = operations.flatMap((operation) => {
+    if (operation.op !== "create") return [];
+    const parentPath = resolveRefPath(operation.parent, knownPaths);
+    return parentPath ? [pathKey([...parentPath, operation.name])] : [];
   });
+  const missingCreates = expectedCreates.filter((path5) => !paths.has(path5));
+  const inspectOperations = operations.filter((operation) => operation.op !== "create");
+  const inspectFailures = [];
+  const propertyMismatches = [];
+  const moveMismatches = [];
+  for (let offset = 0; offset < inspectOperations.length; offset += 20) {
+    const batch = inspectOperations.slice(offset, offset + 20);
+    const targets = batch.map((operation) => operation.target);
+    const inspected = await requestStudio(bridge, CliMsg.V2_INSPECT, { targets, compact: true });
+    const results = Array.isArray(inspected.results) ? inspected.results : [];
+    batch.forEach((operation, index) => {
+      const result = results[index];
+      const targetLabel = refLabel(operation.target);
+      if (!result || result.success === false) {
+        inspectFailures.push(
+          `${targetLabel}: ${String(result?.error ?? "missing inspection result")}`
+        );
+        return;
+      }
+      if (operation.op === "setProperties") {
+        const entries = Array.isArray(result.properties) ? result.properties : [];
+        const actual = new Map(entries.map((entry) => [String(entry.name), entry.value]));
+        for (const [property, expected] of Object.entries(operation.properties)) {
+          const actualValue = actual.get(property);
+          if (!actual.has(property) || !valuesEquivalent(expected, actualValue)) {
+            propertyMismatches.push({
+              target: targetLabel,
+              property,
+              expected,
+              actual: actualValue
+            });
+          }
+        }
+      } else {
+        const instanceId = operation.target.instanceId;
+        const current = nodes.find((node) => instanceId && node.ref.instanceId === instanceId) ?? nodes.find((node) => samePath(node.ref.pathSegments, operation.target.pathSegments));
+        const expectedParent = resolveRefPath(operation.parent, knownPaths);
+        const actualPath = current?.ref.pathSegments;
+        const actualParent = actualPath?.slice(0, -1);
+        if (!expectedParent || !actualParent || !samePath(expectedParent, actualParent)) {
+          moveMismatches.push({
+            target: targetLabel,
+            expectedParent: expectedParent ? expectedParent.join(".") : refLabel(operation.parent),
+            actualParent: actualParent?.join(".")
+          });
+        }
+      }
+    });
+  }
+  return {
+    passed: !tree.truncated && missingCreates.length === 0 && propertyMismatches.length === 0 && moveMismatches.length === 0 && inspectFailures.length === 0,
+    treeNodeCount: tree.nodeCount,
+    treeTruncated: tree.truncated,
+    expectedCreates: expectedCreates.length,
+    foundCreates: expectedCreates.length - missingCreates.length,
+    missingCreates,
+    propertyMismatches,
+    moveMismatches,
+    inspectFailures
+  };
 }
-var propertiesSchema = z.record(z.unknown()).refine(
-  (properties) => Object.keys(properties).length <= 100,
-  "At most 100 properties are allowed per operation"
+function findRepairOperations(operations, verification, originalRoot) {
+  const knownPaths = collectInstancePaths(originalRoot);
+  const missingCreates = new Set(verification.missingCreates);
+  const mismatchedTargets = new Set(verification.propertyMismatches.map((item) => item.target));
+  const mismatchedMoves = new Set(verification.moveMismatches.map((item) => item.target));
+  return operations.filter((operation) => {
+    if (operation.op === "create") {
+      const parentPath = resolveRefPath(operation.parent, knownPaths);
+      return Boolean(parentPath && missingCreates.has(pathKey([...parentPath, operation.name])));
+    }
+    if (operation.op === "setProperties") return mismatchedTargets.has(refLabel(operation.target));
+    return mismatchedMoves.has(refLabel(operation.target));
+  });
+}
+function emptyDecision(rejected) {
+  return {
+    summary: rejected.length > 0 ? "No valid worker proposal was available to apply." : "Workers found no mutations necessary.",
+    acceptedWorkerIds: [],
+    rejected: [],
+    operationOrder: [],
+    verificationChecks: ["Read the requested root back and confirm no mutation was needed."]
+  };
+}
+function publicAssignment(assignment) {
+  return {
+    id: assignment.id,
+    role: assignment.role,
+    objective: assignment.objective,
+    ownedScopes: assignment.ownedScopes,
+    acceptanceCriteria: assignment.acceptanceCriteria
+  };
+}
+function publicWorkerResult(result) {
+  return {
+    workerId: result.assignment.id,
+    summary: result.proposal?.summary,
+    evidence: result.proposal?.evidence ?? [],
+    proposedOperationCount: result.proposal?.operations.length ?? 0,
+    risks: result.proposal?.risks ?? [],
+    verificationSuggestions: result.proposal?.verificationSuggestions ?? [],
+    error: result.error
+  };
+}
+function collectRefKeys(node, output) {
+  for (const key of parallelRefKeys(node.ref)) output.add(key);
+  node.children?.forEach((child) => collectRefKeys(child, output));
+}
+function collectInstancePaths(root) {
+  const result = /* @__PURE__ */ new Map();
+  for (const node of flattenTree([root])) {
+    if (node.ref.pathSegments) {
+      if (node.ref.instanceId) result.set(`id:${node.ref.instanceId}`, node.ref.pathSegments);
+      result.set(`path:${pathKey(node.ref.pathSegments)}`, node.ref.pathSegments);
+    }
+  }
+  return result;
+}
+function flattenTree(roots) {
+  const result = [];
+  const visit = (node) => {
+    result.push(node);
+    node.children?.forEach(visit);
+  };
+  roots.forEach(visit);
+  return result;
+}
+function isKnownParallelRef(ref2, known) {
+  const keys = parallelRefKeys(ref2);
+  return keys.length > 0 && keys.every((key) => known.has(key));
+}
+function isParallelRefWithinScopes(ref2, scopes) {
+  if (ref2.pathSegments) {
+    return scopes.some(
+      (scope) => scope.pathSegments && parallelPathIsWithin(ref2.pathSegments, scope.pathSegments)
+    );
+  }
+  return scopes.some((scope) => Boolean(ref2.instanceId && scope.instanceId === ref2.instanceId));
+}
+function operationTarget(operation) {
+  if (operation.op === "create") {
+    const parentPath = operation.parent.pathSegments;
+    return {
+      key: `${refKey(operation.parent)}/create:${operation.name}`,
+      path: parentPath ? [...parentPath, operation.name] : void 0
+    };
+  }
+  return { key: refKey(operation.target), path: operation.target.pathSegments };
+}
+function parallelRefKeys(ref2) {
+  const keys = [];
+  if (ref2.instanceId) keys.push(`id:${ref2.instanceId}`);
+  if (ref2.pathSegments) keys.push(`path:${pathKey(ref2.pathSegments)}`);
+  if (ref2.instanceId && ref2.pathSegments) {
+    keys.push(`pair:${ref2.instanceId}:${pathKey(ref2.pathSegments)}`);
+  }
+  return keys;
+}
+function refKey(ref2) {
+  return parallelRefKeys(ref2)[0] ?? "invalid-ref";
+}
+function refLabel(ref2) {
+  return ref2.pathSegments?.join(".") ?? ref2.instanceId ?? "unknown-instance";
+}
+function resolveRefPath(ref2, known) {
+  if (ref2.pathSegments) return ref2.pathSegments;
+  return ref2.instanceId ? known.get(`id:${ref2.instanceId}`) : void 0;
+}
+function pathKey(path5) {
+  return path5.join("\0");
+}
+function parallelPathIsWithin(target, scope) {
+  return target.length >= scope.length && scope.every((segment, index) => target[index] === segment);
+}
+function parallelPathsOverlap(left, right) {
+  return parallelPathIsWithin(left, right) || parallelPathIsWithin(right, left);
+}
+function samePath(left, right) {
+  return Boolean(
+    left && right && left.length === right.length && left.every((part, index) => part === right[index])
+  );
+}
+function parallelRootPathToSegments(path5) {
+  const trimmed = path5.trim();
+  const bracketSegments = [...trimmed.matchAll(/\["((?:\\.|[^"])*)"\]/g)].map(
+    (match) => JSON.parse(`"${match[1]}"`)
+  );
+  if (bracketSegments.length > 0) return bracketSegments;
+  const segments = trimmed.replace(/^game\.?/i, "").split(".").map((part) => part.trim()).filter(Boolean);
+  if (segments.length === 0) throw new Error("rootPath must identify a Studio instance");
+  return segments;
+}
+function parseJson(text) {
+  const trimmed = text.trim();
+  const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)?.[1] ?? trimmed;
+  try {
+    return JSON.parse(fenced);
+  } catch {
+    const start = fenced.indexOf("{");
+    const end = fenced.lastIndexOf("}");
+    if (start >= 0 && end > start) return JSON.parse(fenced.slice(start, end + 1));
+    throw new Error("Sampling response did not contain a JSON object");
+  }
+}
+function extractSamplingText(content) {
+  const blocks = Array.isArray(content) ? content : [content];
+  const text = blocks.flatMap((block) => {
+    if (block && typeof block === "object" && block.type === "text") {
+      const value = block.text;
+      return typeof value === "string" ? [value] : [];
+    }
+    return [];
+  }).join("\n");
+  if (!text) throw new Error("Sampling response did not contain text");
+  return text;
+}
+function valuesEquivalent(expected, actual) {
+  if (typeof expected === "string" && typeof actual === "string") {
+    if (expected.startsWith("#") && actual.startsWith("#"))
+      return expected.toUpperCase() === actual.toUpperCase();
+    if (actual.startsWith("Enum.")) return actual.endsWith(`.${expected.split(".").at(-1)}`);
+    return expected === actual;
+  }
+  if (typeof expected === "number" && typeof actual === "number")
+    return Math.abs(expected - actual) < 1e-6;
+  if (Array.isArray(expected) && Array.isArray(actual)) {
+    return expected.length === actual.length && expected.every((item, index) => valuesEquivalent(item, actual[index]));
+  }
+  if (expected && actual && typeof expected === "object" && typeof actual === "object") {
+    const left = expected;
+    const right = actual;
+    return Object.keys(left).every((key) => valuesEquivalent(left[key], right[key]));
+  }
+  return Object.is(expected, actual);
+}
+function emit(server, type, data) {
+  void server.sendLoggingMessage({
+    level: "info",
+    logger: "dominus.multi_agent",
+    data: { type, ...data }
+  }).catch(() => void 0);
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var propertiesSchema2 = z.record(z.unknown()).refine(
+  (properties) => Object.keys(properties).length <= 100 && !Object.keys(properties).some((name) => ["Parent", "ClassName", "Source"].includes(name)),
+  "At most 100 properties are allowed; Parent, ClassName, and Source require dedicated operations"
 );
 var setPropertiesOperation = z.object({
   op: z.literal("setProperties"),
   target: instanceRefSchema,
-  properties: propertiesSchema
+  properties: propertiesSchema2
 });
 var createOperation = z.object({
   op: z.literal("create"),
   parent: instanceRefSchema,
   className: z.string().min(1).max(100),
   name: z.string().min(1).max(256),
-  properties: propertiesSchema.optional()
+  properties: propertiesSchema2.optional()
 });
 var moveOperation = z.object({
   op: z.literal("move"),
@@ -1463,181 +1977,275 @@ var mutationOperation = z.discriminatedUnion("op", [
   createOperation,
   moveOperation
 ]);
-var uiNodeSchema = z.lazy(() => z.object({
-  ClassName: z.string().min(1).max(100),
-  Name: z.string().min(1).max(256).optional(),
-  properties: propertiesSchema.optional(),
-  Children: z.array(uiNodeSchema).max(1e3).optional()
-}));
+var uiNodeSchema = z.lazy(
+  () => z.object({
+    ClassName: z.string().min(1).max(100),
+    Name: z.string().min(1).max(256).optional(),
+    properties: propertiesSchema2.optional(),
+    Children: z.array(uiNodeSchema).max(1e3).optional()
+  })
+);
 function registerStudioTools(server, bridge) {
-  server.registerTool("studio_get_tree", {
-    title: "Inspect Studio Tree",
-    description: "Read a deterministic Studio hierarchy and receive stable instance refs. Use refs from this result in later calls.",
-    inputSchema: {
-      root: instanceRefSchema.optional(),
-      maxDepth: z.number().int().min(0).max(12).optional().default(3),
-      maxNodes: z.number().int().min(1).max(5e3).optional().default(1e3)
+  server.registerTool(
+    "studio_get_tree",
+    {
+      title: "Inspect Studio Tree",
+      description: "Read a deterministic Studio hierarchy and receive stable instance refs. Use refs from this result in later calls.",
+      inputSchema: {
+        root: instanceRefSchema.optional(),
+        maxDepth: z.number().int().min(0).max(12).optional().default(3),
+        maxNodes: z.number().int().min(1).max(5e3).optional().default(1e3)
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
     },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
-  }, ({ root, maxDepth, maxNodes }) => callStudio(bridge, CliMsg.V2_GET_TREE, {
-    root: root ? ref(root) : void 0,
-    maxDepth,
-    maxNodes
-  }));
-  server.registerTool("studio_inspect", {
-    title: "Inspect Studio Instances",
-    description: "Read typed property values and immediate children for up to 20 instance refs. Returns writable metadata from live ReflectionService.",
-    inputSchema: {
-      targets: z.array(instanceRefSchema).min(1).max(20),
-      compact: z.boolean().optional().default(true)
+    ({ root, maxDepth, maxNodes }) => callStudio(bridge, CliMsg.V2_GET_TREE, {
+      root: root ? ref(root) : void 0,
+      maxDepth,
+      maxNodes
+    })
+  );
+  server.registerTool(
+    "studio_inspect",
+    {
+      title: "Inspect Studio Instances",
+      description: "Read typed property values and immediate children for up to 20 instance refs. Returns writable metadata from live ReflectionService.",
+      inputSchema: {
+        targets: z.array(instanceRefSchema).min(1).max(20),
+        compact: z.boolean().optional().default(true)
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    ({ targets, compact }) => callStudio(bridge, CliMsg.V2_INSPECT, { targets, compact })
+  );
+  server.registerTool(
+    "studio_get_selection",
+    {
+      title: "Get Studio Selection",
+      description: "Return the user current Roblox Studio selection as stable instance refs.",
+      inputSchema: {},
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    () => callStudio(bridge, CliMsg.V2_GET_SELECTION, {})
+  );
+  server.registerTool(
+    "studio_read_script",
+    {
+      title: "Read Studio Script",
+      description: "Read a Script, LocalScript, or ModuleScript and receive its source plus a revision required for conflict-safe updates.",
+      inputSchema: { target: instanceRefSchema },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
     },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
-  }, ({ targets, compact }) => callStudio(bridge, CliMsg.V2_INSPECT, { targets, compact }));
-  server.registerTool("studio_get_selection", {
-    title: "Get Studio Selection",
-    description: "Return the user current Roblox Studio selection as stable instance refs.",
-    inputSchema: {},
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
-  }, () => callStudio(bridge, CliMsg.V2_GET_SELECTION, {}));
-  server.registerTool("studio_read_script", {
-    title: "Read Studio Script",
-    description: "Read a Script, LocalScript, or ModuleScript and receive its source plus a revision required for conflict-safe updates.",
-    inputSchema: { target: instanceRefSchema },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
-  }, ({ target }) => callStudio(bridge, CliMsg.V2_READ_SCRIPT, { target }));
-  server.registerTool("studio_update_script", {
-    title: "Update Studio Script",
-    description: "Replace script source only if expectedRevision still matches the editor. Read the script again after updating to verify it.",
-    inputSchema: {
-      target: instanceRefSchema,
-      source: z.string().max(75e4),
-      expectedRevision: z.string().regex(/^\d+:[0-9a-f]{8}$/)
+    ({ target }) => callStudio(bridge, CliMsg.V2_READ_SCRIPT, { target })
+  );
+  server.registerTool(
+    "studio_update_script",
+    {
+      title: "Update Studio Script",
+      description: "Replace script source only if expectedRevision still matches the editor. Read the script again after updating to verify it.",
+      inputSchema: {
+        target: instanceRefSchema,
+        source: z.string().max(75e4),
+        expectedRevision: z.string().regex(/^\d+:[0-9a-f]{8}$/)
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      }
     },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
-  }, ({ target, source, expectedRevision }) => callStudio(
-    bridge,
-    CliMsg.V2_UPDATE_SCRIPT,
-    { target, source, expectedRevision },
-    6e4
-  ));
-  server.registerTool("studio_apply", {
-    title: "Apply Atomic Studio Mutations",
-    description: "Atomically set properties, create instances, and move instances. Any failed operation cancels and undoes the entire batch.",
-    inputSchema: { operations: z.array(mutationOperation).min(1).max(100) },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
-  }, ({ operations }) => callStudio(bridge, CliMsg.V2_APPLY, { operations }, 6e4));
-  server.registerTool("studio_delete_instances", {
-    title: "Delete Studio Instances",
-    description: "Destructively delete up to 50 instances in one undoable recording. Only call when the user explicitly requested deletion or cleanup.",
-    inputSchema: {
-      targets: z.array(instanceRefSchema).min(1).max(50),
-      confirm: z.literal(true)
+    ({ target, source, expectedRevision }) => callStudio(bridge, CliMsg.V2_UPDATE_SCRIPT, { target, source, expectedRevision }, 6e4)
+  );
+  server.registerTool(
+    "studio_apply",
+    {
+      title: "Apply Atomic Studio Mutations",
+      description: "Atomically set properties, create instances, and move instances. Any failed operation cancels and undoes the entire batch.",
+      inputSchema: { operations: z.array(mutationOperation).min(1).max(100) },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
     },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false }
-  }, ({ targets, confirm }) => callStudio(bridge, CliMsg.V2_DELETE, { targets, confirm }, 6e4));
-  server.registerTool("studio_build_ui", {
-    title: "Build Atomic Roblox UI",
-    description: "Build and validate a declarative UI tree off-tree, then commit it in one undoable operation. Existing UI is replaced only when replaceExisting is true.",
-    inputSchema: {
-      parent: instanceRefSchema.optional(),
-      tree: uiNodeSchema,
-      replaceExisting: z.boolean().optional().default(false),
-      maxDepth: z.number().int().min(1).max(50).optional().default(30),
-      maxNodes: z.number().int().min(1).max(3e3).optional().default(1e3)
+    ({ operations }) => callStudio(bridge, CliMsg.V2_APPLY, { operations }, 6e4)
+  );
+  server.registerTool(
+    "studio_delete_instances",
+    {
+      title: "Delete Studio Instances",
+      description: "Destructively delete up to 50 instances in one undoable recording. Only call when the user explicitly requested deletion or cleanup.",
+      inputSchema: {
+        targets: z.array(instanceRefSchema).min(1).max(50),
+        confirm: z.literal(true)
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      }
     },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false }
-  }, ({ parent, tree, replaceExisting, maxDepth, maxNodes }) => callStudio(
-    bridge,
-    CliMsg.V2_BUILD_UI,
-    { parent, tree, replaceExisting, maxDepth, maxNodes },
-    12e4
-  ));
-  server.registerTool("studio_snapshot_ui", {
-    title: "Snapshot Roblox UI",
-    description: "Serialize a live UI subtree into typed, studio_build_ui-compatible data for fidelity checks and read-back verification.",
-    inputSchema: {
-      target: instanceRefSchema,
-      maxDepth: z.number().int().min(0).max(50).optional().default(30)
+    ({ targets, confirm }) => callStudio(bridge, CliMsg.V2_DELETE, { targets, confirm }, 6e4)
+  );
+  server.registerTool(
+    "studio_build_ui",
+    {
+      title: "Build Atomic Roblox UI",
+      description: "Build and validate a declarative UI tree off-tree, then commit it in one undoable operation. Existing UI is replaced only when replaceExisting is true.",
+      inputSchema: {
+        parent: instanceRefSchema.optional(),
+        tree: uiNodeSchema,
+        replaceExisting: z.boolean().optional().default(false),
+        maxDepth: z.number().int().min(1).max(50).optional().default(30),
+        maxNodes: z.number().int().min(1).max(3e3).optional().default(1e3)
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      }
     },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
-  }, ({ target, maxDepth }) => callStudio(bridge, CliMsg.V2_SNAPSHOT_UI, { target, maxDepth }, 12e4));
-  server.registerTool("studio_run_test", {
-    title: "Run Roblox Studio Test",
-    description: "Run a bounded StudioTestService run, play, or multiplayer scenario. The game test harness must call StudioTestService:EndTest with its result.",
-    inputSchema: {
-      mode: z.enum(["run", "play", "multiplayer"]).optional().default("run"),
-      args: z.unknown().optional(),
-      players: z.number().int().min(1).max(8).optional().default(1),
-      timeoutMs: z.number().int().min(5e3).max(6e5).optional().default(12e4)
+    ({ parent, tree, replaceExisting, maxDepth, maxNodes }) => callStudio(
+      bridge,
+      CliMsg.V2_BUILD_UI,
+      { parent, tree, replaceExisting, maxDepth, maxNodes },
+      12e4
+    )
+  );
+  server.registerTool(
+    "studio_snapshot_ui",
+    {
+      title: "Snapshot Roblox UI",
+      description: "Serialize a live UI subtree into typed, studio_build_ui-compatible data for fidelity checks and read-back verification.",
+      inputSchema: {
+        target: instanceRefSchema,
+        maxDepth: z.number().int().min(0).max(50).optional().default(30)
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
     },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
-  }, ({ mode, args, players, timeoutMs }) => callStudio(
-    bridge,
-    CliMsg.V2_RUN_TEST,
-    { mode, args, players, timeoutMs },
-    timeoutMs + 15e3
-  ));
-  server.registerTool("studio_get_output", {
-    title: "Read Studio Output",
-    description: "Read the bounded Studio output buffer, optionally filtered by severity. Dominus transport messages are excluded.",
-    inputSchema: {
-      limit: z.number().int().min(1).max(500).optional().default(100),
-      level: z.enum(["info", "warn", "error"]).optional()
+    ({ target, maxDepth }) => callStudio(bridge, CliMsg.V2_SNAPSHOT_UI, { target, maxDepth }, 12e4)
+  );
+  server.registerTool(
+    "studio_run_test",
+    {
+      title: "Run Roblox Studio Test",
+      description: "Run a bounded StudioTestService run, play, or multiplayer scenario. The game test harness must call StudioTestService:EndTest with its result.",
+      inputSchema: {
+        mode: z.enum(["run", "play", "multiplayer"]).optional().default("run"),
+        args: z.unknown().optional(),
+        players: z.number().int().min(1).max(8).optional().default(1),
+        timeoutMs: z.number().int().min(5e3).max(6e5).optional().default(12e4)
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    ({ mode, args, players, timeoutMs }) => callStudio(
+      bridge,
+      CliMsg.V2_RUN_TEST,
+      { mode, args, players, timeoutMs },
+      timeoutMs + 15e3
+    )
+  );
+  server.registerTool(
+    "studio_get_output",
+    {
+      title: "Read Studio Output",
+      description: "Read the bounded Studio output buffer, optionally filtered by severity. Dominus transport messages are excluded.",
+      inputSchema: {
+        limit: z.number().int().min(1).max(500).optional().default(100),
+        level: z.enum(["info", "warn", "error"]).optional()
+      },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    ({ limit, level }) => callStudio(bridge, CliMsg.V2_GET_OUTPUT, { limit, level })
+  );
+  server.registerTool(
+    "studio_get_reflection",
+    {
+      title: "Read Live Roblox Reflection",
+      description: "Read current ReflectionService fields for a class in the connected Studio, including Type, Display category, and permission metadata.",
+      inputSchema: { className: z.string().min(1).max(100) },
+      outputSchema: toolOutputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
     },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
-  }, ({ limit, level }) => callStudio(bridge, CliMsg.V2_GET_OUTPUT, { limit, level }));
-  server.registerTool("studio_get_reflection", {
-    title: "Read Live Roblox Reflection",
-    description: "Read current ReflectionService fields for a class in the connected Studio, including Type, Display category, and permission metadata.",
-    inputSchema: { className: z.string().min(1).max(100) },
-    outputSchema: toolOutputSchema,
-    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
-  }, ({ className }) => callStudio(bridge, CliMsg.V2_GET_REFLECTION, { className }));
+    ({ className }) => callStudio(bridge, CliMsg.V2_GET_REFLECTION, { className })
+  );
 }
 
 // src/mcp/server.ts
-var VERSION = "2.1.1";
+var VERSION = "2.2.1";
 function createDominusMcpServer(bridge) {
-  const server = new McpServer({
-    name: "dominus-2",
-    version: VERSION
-  }, {
-    instructions: DOMINUS_MCP_INSTRUCTIONS
-  });
+  const server = new McpServer(
+    {
+      name: "dominus-2",
+      version: VERSION
+    },
+    {
+      instructions: DOMINUS_MCP_INSTRUCTIONS
+    }
+  );
   registerConnectionTools(server, bridge);
   registerStudioTools(server, bridge);
+  registerParallelTaskTool(server, bridge);
   registerDocsTools(server);
   registerDominusResources(server, bridge);
   return server;
 }
 async function createStudioBridge(port) {
-  if (await isPortInUse(port)) {
-    const client = new DominusClient(port);
-    await client.connect();
-    return client;
-  }
-  const server = new DominusServer(port);
-  try {
-    await server.start();
-    return server;
-  } catch (err) {
-    const error = err;
-    if (error.code !== "EADDRINUSE") throw err;
-    const client = new DominusClient(port);
-    await client.connect();
-    return client;
-  }
+  return ensureBridgeDaemon(port);
 }
 async function startMcpServer() {
   const config = loadConfig();