dominus-cli 2.1.1 → 2.2.0

package/dist/mcp.js

@@ -76,6 +76,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",
@@ -863,6 +889,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 +901,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 +975,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";
@@ -1401,57 +1468,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((path4) => parallelPathsOverlap(target.path, path4)) || 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((path4) => !paths.has(path4));
+  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
+  };
+}
+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));
   });
 }
-var propertiesSchema = z.record(z.unknown()).refine(
-  (properties) => Object.keys(properties).length <= 100,
-  "At most 100 properties are allowed per operation"
+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(path4) {
+  return path4.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(path4) {
+  const trimmed = path4.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,160 +2307,269 @@ 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
+      }
+    },
+    ({ 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
+      }
+    },
+    ({ 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: 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}$/)
+    ({ 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: 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)
+    ({ 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: 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)
+    ({ 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: 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)
+    ({ 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
+      }
     },
-    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)
+    ({ 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
+      }
     },
-    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()
+    ({ 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.0";
 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;