dominus-cli 0.6.0 → 2.0.0

package/dist/mcp.js

@@ -1,71 +1,2456 @@
 #!/usr/bin/env node
+import { nanoid } from 'nanoid';
+import fs3 from 'fs';
+import path2 from 'path';
+import os from 'os';
+import initSqlJs from 'sql.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import { WebSocket, WebSocketServer } from 'ws';
 import { EventEmitter } from 'events';
-import { nanoid } from 'nanoid';
-import fs from 'fs';
-import initSqlJs from 'sql.js';
-import path from 'path';
-import os from 'os';
+import OpenAI from 'openai';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function createMessage(type, payload) {
+  return { id: nanoid(), type, payload, ts: Date.now() };
+}
+function parseMessage(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`Failed to parse WebSocket message: ${raw.slice(0, 100)}`);
+  }
+}
+function serializeMessage(msg) {
+  return JSON.stringify(msg);
+}
+var StudioMsg, CliMsg;
+var init_protocol = __esm({
+  "src/transport/protocol.ts"() {
+    StudioMsg = {
+      CONNECTED: "studio:connected",
+      DISCONNECTED: "studio:disconnected",
+      EXPLORER: "studio:explorer",
+      OUTPUT: "studio:output",
+      ERROR: "studio:error",
+      SELECTION: "studio:selection",
+      SCRIPT_CONTENT: "studio:script:content",
+      SCRIPT_CHANGED: "studio:script:changed",
+      RESPONSE: "studio:response",
+      REFLECTION: "studio:reflection",
+      TEST_RESULTS: "studio:test:results"
+    };
+    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"
+    };
+  }
+});
+function resolveProviderSettings(config) {
+  const providerInfo = PROVIDERS[config.provider];
+  return {
+    baseUrl: config.apiBaseUrl || providerInfo?.baseUrl || PROVIDERS.openrouter.baseUrl,
+    model: config.model || providerInfo?.defaultModel || "gpt-4o"
+  };
+}
+function ensureDir() {
+  if (!fs3.existsSync(DOMINUS_DIR)) {
+    fs3.mkdirSync(DOMINUS_DIR, { recursive: true });
+  }
+}
+function readJson(filePath, defaults) {
+  try {
+    if (fs3.existsSync(filePath)) {
+      const raw = fs3.readFileSync(filePath, "utf-8");
+      return { ...defaults, ...JSON.parse(raw) };
+    }
+  } catch {
+  }
+  return { ...defaults };
+}
+function writeJson(filePath, data) {
+  ensureDir();
+  fs3.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+function loadConfig() {
+  ensureDir();
+  return readJson(CONFIG_PATH, DEFAULTS);
+}
+function saveConfig(config) {
+  writeJson(CONFIG_PATH, config);
+}
+function getDbPath() {
+  ensureDir();
+  return DB_PATH;
+}
+function createConfigAccess() {
+  return {
+    get(key) {
+      const config = loadConfig();
+      return config[key];
+    },
+    set(key, value) {
+      const config = loadConfig();
+      config[key] = value;
+      saveConfig(config);
+    },
+    getAll() {
+      return loadConfig();
+    }
+  };
+}
+var DOMINUS_DIR, CONFIG_PATH, DB_PATH, PROVIDERS, DEFAULTS;
+var init_config = __esm({
+  "src/config/config.ts"() {
+    DOMINUS_DIR = path2.join(os.homedir(), ".dominus");
+    CONFIG_PATH = path2.join(DOMINUS_DIR, "config.json");
+    DB_PATH = path2.join(DOMINUS_DIR, "dominus.db");
+    path2.join(DOMINUS_DIR, "rules.json");
+    PROVIDERS = {
+      openai: {
+        name: "OpenAI",
+        baseUrl: "https://api.openai.com/v1",
+        envVar: "OPENAI_API_KEY",
+        defaultModel: "gpt-5.3-codex"
+      },
+      anthropic: {
+        name: "Anthropic",
+        baseUrl: "https://api.anthropic.com/v1/",
+        envVar: "ANTHROPIC_API_KEY",
+        defaultModel: "claude-sonnet-4-6"
+      },
+      gemini: {
+        name: "Google Gemini",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+        envVar: "GEMINI_API_KEY",
+        defaultModel: "gemini-3.1-pro"
+      },
+      xai: {
+        name: "xAI (Grok)",
+        baseUrl: "https://api.x.ai/v1",
+        envVar: "XAI_API_KEY",
+        defaultModel: "grok-4.2"
+      },
+      openrouter: {
+        name: "OpenRouter",
+        baseUrl: "https://openrouter.ai/api/v1",
+        envVar: "OPENROUTER_API_KEY",
+        defaultModel: "anthropic/claude-sonnet-4-6"
+      },
+      custom: {
+        name: "Custom",
+        baseUrl: "",
+        envVar: "",
+        defaultModel: ""
+      }
+    };
+    DEFAULTS = {
+      provider: "openai",
+      apiBaseUrl: "",
+      model: "",
+      port: 18088,
+      maxToolIterations: 25,
+      maxVerifyRetries: 3,
+      tokenBudget: 128e3,
+      autoIndex: true,
+      autoLearn: true,
+      userName: "Developer"
+    };
+  }
+});
+function persist() {
+  if (!db) return;
+  const data = db.export();
+  fs3.writeFileSync(dbPath, Buffer.from(data));
+}
+async function initMemoryStore() {
+  if (db) return;
+  dbPath = getDbPath();
+  const SQL = await initSqlJs();
+  if (fs3.existsSync(dbPath)) {
+    const buffer = fs3.readFileSync(dbPath);
+    db = new SQL.Database(buffer);
+  } else {
+    db = new SQL.Database();
+  }
+  db.run(SCHEMA);
+  persist();
+}
+function getDb() {
+  if (!db) throw new Error("Memory store not initialized. Call initMemoryStore() first.");
+  return db;
+}
+function storeFact(fact) {
+  const d = getDb();
+  d.run(
+    `INSERT INTO facts (project_id, content, category, source, relevance, created_at, accessed_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [
+      fact.projectId,
+      fact.content,
+      fact.category,
+      fact.source ?? null,
+      fact.relevance,
+      fact.createdAt,
+      fact.accessedAt
+    ]
+  );
+  persist();
+  const stmt = d.prepare("SELECT last_insert_rowid()");
+  stmt.step();
+  const row = stmt.get();
+  stmt.free();
+  return row?.[0] ?? 0;
+}
+function recallFacts(projectId, query, limit = 10) {
+  const d = getDb();
+  const keywords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  if (keywords.length === 0) {
+    const result2 = d.exec(
+      `SELECT * FROM facts WHERE project_id = ? ORDER BY relevance DESC, accessed_at DESC LIMIT ?`,
+      [projectId, limit]
+    );
+    return rowsToFacts(result2);
+  }
+  const likeClauses = keywords.map(() => `LOWER(content) LIKE ?`).join(" OR ");
+  const likeParams = keywords.map((k) => `%${k}%`);
+  const result = d.exec(
+    `SELECT * FROM facts WHERE project_id = ? AND (${likeClauses})
+     ORDER BY relevance DESC, accessed_at DESC LIMIT ?`,
+    [projectId, ...likeParams, limit]
+  );
+  const facts = rowsToFacts(result);
+  for (const fact of facts) {
+    if (fact.id) {
+      d.run(`UPDATE facts SET accessed_at = ? WHERE id = ?`, [Date.now(), fact.id]);
+    }
+  }
+  if (facts.length > 0) persist();
+  return facts;
+}
+function rowsToFacts(result) {
+  if (!result[0]) return [];
+  return result[0].values.map((row) => ({
+    id: row[0],
+    projectId: row[1],
+    content: row[2],
+    category: row[3],
+    source: row[4],
+    relevance: row[5],
+    createdAt: row[6],
+    accessedAt: row[7]
+  }));
+}
+function getProjectSummaries(projectId, limit = 20) {
+  const d = getDb();
+  const result = d.exec(
+    `SELECT * FROM summaries WHERE project_id = ? ORDER BY created_at DESC LIMIT ?`,
+    [projectId, limit]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map((row) => ({
+    id: row[0],
+    projectId: row[1],
+    sessionId: row[2],
+    summary: row[3],
+    createdAt: row[4]
+  }));
+}
+function getScriptIndex(projectId) {
+  const d = getDb();
+  const result = d.exec(
+    `SELECT path, summary, class_name FROM script_index WHERE project_id = ? ORDER BY path`,
+    [projectId]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map((row) => ({
+    path: row[0],
+    summary: row[1] || void 0,
+    className: row[2]
+  }));
+}
+var db, dbPath, SCHEMA;
+var init_store = __esm({
+  "src/memory/store.ts"() {
+    init_config();
+    db = null;
+    SCHEMA = `
+CREATE TABLE IF NOT EXISTS facts (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id  TEXT NOT NULL,
+  content     TEXT NOT NULL,
+  category    TEXT NOT NULL,
+  source      TEXT,
+  relevance   REAL DEFAULT 1.0,
+  created_at  INTEGER NOT NULL,
+  accessed_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS summaries (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id  TEXT NOT NULL,
+  session_id  TEXT NOT NULL,
+  summary     TEXT NOT NULL,
+  created_at  INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id  TEXT NOT NULL,
+  role        TEXT NOT NULL,
+  content     TEXT NOT NULL,
+  tool_name   TEXT,
+  created_at  INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS script_index (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id  TEXT NOT NULL,
+  path        TEXT NOT NULL,
+  class_name  TEXT NOT NULL,
+  summary     TEXT,
+  line_count  INTEGER,
+  last_hash   TEXT,
+  updated_at  INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_facts_project ON facts(project_id);
+CREATE INDEX IF NOT EXISTS idx_facts_category ON facts(project_id, category);
+CREATE INDEX IF NOT EXISTS idx_scripts_project ON script_index(project_id);
+CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+CREATE INDEX IF NOT EXISTS idx_summaries_project ON summaries(project_id);
+`;
+  }
+});
+async function getRobloxApiReference(name, opts = {}) {
+  const normalizedName = normalizeLookupName(name);
+  const kinds = opts.kind && opts.kind !== "any" ? [opts.kind] : Object.keys(KIND_FOLDERS);
+  for (const kind of kinds) {
+    const doc = await readReferenceYaml(normalizedName, kind, opts);
+    if (!doc) continue;
+    const reference = parseReferenceYaml(doc.content, {
+      kind,
+      sourceUrl: doc.sourceUrl
+    });
+    markDefinedOn(reference, reference.name);
+    if (opts.includeInherited && reference.kind === "class") {
+      const inherited = await collectInheritedMembers(reference, opts, /* @__PURE__ */ new Set([reference.name]));
+      reference.inheritedClasses = inherited.classes;
+      reference.inheritedMembers = inherited.members;
+    }
+    return reference;
+  }
+  throw new Error(`Roblox API reference not found for "${name}"`);
+}
+async function collectInheritedMembers(reference, opts, visited) {
+  const classes = [];
+  const members = {};
+  for (const parent of reference.inherits) {
+    if (!parent || visited.has(parent)) continue;
+    visited.add(parent);
+    const doc = await readReferenceYaml(parent, "class", opts);
+    if (!doc) continue;
+    const parentReference = parseReferenceYaml(doc.content, {
+      kind: "class",
+      sourceUrl: doc.sourceUrl
+    });
+    markDefinedOn(parentReference, parentReference.name);
+    classes.push(parentReference.name);
+    mergeMembers(members, parentReference.members);
+    const inherited = await collectInheritedMembers(parentReference, opts, visited);
+    classes.push(...inherited.classes);
+    mergeMembers(members, inherited.members);
+  }
+  return { classes, members };
+}
+function markDefinedOn(reference, className) {
+  for (const section of Object.values(reference.members)) {
+    for (const member of section) {
+      member.definedOn = className;
+    }
+  }
+}
+function mergeMembers(target, source) {
+  for (const [section, members] of Object.entries(source)) {
+    target[section] ??= [];
+    target[section].push(...members);
+  }
+}
+async function searchRobloxApi(query, opts = {}) {
+  const limit = Math.max(1, Math.min(opts.limit ?? 10, 50));
+  const normalizedQuery = normalizeSearchText(query);
+  const kinds = opts.kind && opts.kind !== "any" ? [opts.kind] : Object.keys(KIND_FOLDERS);
+  const entries = await listReferenceEntries(opts);
+  return entries.filter((entry) => kinds.includes(entry.kind)).map((entry) => ({
+    ...entry,
+    score: scoreSearchResult(normalizedQuery, entry.name, entry.kind)
+  })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.name.localeCompare(b.name)).slice(0, limit);
+}
+function parseReferenceYaml(raw, opts = {}) {
+  const kind = opts.kind ?? normalizeKind(readTopScalar(raw, "type")) ?? "class";
+  const members = {};
+  for (const section of MEMBER_SECTIONS) {
+    const parsed = parseMemberSection(raw, section);
+    if (parsed.length > 0) {
+      members[section] = parsed;
+    }
+  }
+  return {
+    name: readTopScalar(raw, "name") || "Unknown",
+    kind,
+    summary: cleanDocText(readTopScalar(raw, "summary")),
+    description: cleanDocText(readTopScalar(raw, "description")),
+    inherits: readTopList(raw, "inherits"),
+    tags: readTopList(raw, "tags"),
+    deprecationMessage: cleanDocText(readTopScalar(raw, "deprecation_message")),
+    sourceUrl: opts.sourceUrl ?? "",
+    members
+  };
+}
+function normalizeKind(value) {
+  if (value === "class" || value === "datatype" || value === "enum" || value === "global" || value === "library") {
+    return value;
+  }
+  return void 0;
+}
+async function readReferenceYaml(name, kind, opts) {
+  const localRoot = resolveDocsRoot(opts.docsRoot);
+  const folder = KIND_FOLDERS[kind];
+  const fileName = `${name}.yaml`;
+  if (localRoot) {
+    const localPath = path2.join(localRoot, folder, fileName);
+    if (fs3.existsSync(localPath)) {
+      return {
+        content: fs3.readFileSync(localPath, "utf-8"),
+        sourceUrl: toCreatorDocsUrl(kind, name)
+      };
+    }
+  }
+  const sourceUrl = `${GITHUB_RAW_BASE}/${folder}/${encodeURIComponent(fileName)}`;
+  try {
+    return {
+      content: await fetchText(sourceUrl),
+      sourceUrl: toCreatorDocsUrl(kind, name)
+    };
+  } catch {
+    return null;
+  }
+}
+async function listReferenceEntries(opts) {
+  const localRoot = resolveDocsRoot(opts.docsRoot);
+  if (localRoot) {
+    const entries = [];
+    for (const [kind, folder] of Object.entries(KIND_FOLDERS)) {
+      const dir = path2.join(localRoot, folder);
+      if (!fs3.existsSync(dir)) continue;
+      for (const file of fs3.readdirSync(dir)) {
+        if (!file.endsWith(".yaml")) continue;
+        const name = path2.basename(file, ".yaml");
+        entries.push({ name, kind, score: 0, sourceUrl: toCreatorDocsUrl(kind, name) });
+      }
+    }
+    return entries;
+  }
+  const tree = await getRemoteTree();
+  const prefix = "content/en-us/reference/engine/";
+  return tree.filter((entry) => entry.type === "blob").map((entry) => entry.path).filter((entryPath) => entryPath.startsWith(prefix) && entryPath.endsWith(".yaml")).flatMap((entryPath) => {
+    const rest = entryPath.slice(prefix.length);
+    const [folder, file] = rest.split("/");
+    const kind = folderToKind(folder);
+    if (!kind || !file) return [];
+    const name = path2.basename(file, ".yaml");
+    return [{ name, kind, score: 0, sourceUrl: toCreatorDocsUrl(kind, name) }];
+  });
+}
+async function getRemoteTree() {
+  if (remoteTreeCache) return remoteTreeCache;
+  const payload = JSON.parse(await fetchText(GITHUB_TREE_URL));
+  remoteTreeCache = payload.tree ?? [];
+  return remoteTreeCache;
+}
+function folderToKind(folder) {
+  for (const [kind, value] of Object.entries(KIND_FOLDERS)) {
+    if (value === folder) return kind;
+  }
+  return void 0;
+}
+function resolveDocsRoot(explicitRoot) {
+  const candidates = [
+    explicitRoot,
+    process.env.ROBLOX_CREATOR_DOCS_PATH,
+    path2.join(process.cwd(), ".tmp", "creator-docs")
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    const normalized = normalizeDocsRoot(candidate);
+    if (normalized && fs3.existsSync(normalized)) return normalized;
+  }
+  return null;
+}
+function normalizeDocsRoot(root) {
+  const engineRoot = path2.join(root, "content", "en-us", "reference", "engine");
+  if (fs3.existsSync(engineRoot)) return engineRoot;
+  const directClasses = path2.join(root, "classes");
+  if (fs3.existsSync(directClasses)) return root;
+  return null;
+}
+function normalizeLookupName(name) {
+  const trimmed = name.trim();
+  const ownerName = trimmed.split(":")[0];
+  const lastToken = ownerName.split(".").pop() ?? ownerName;
+  return lastToken.replace(/[^A-Za-z0-9_]/g, "");
+}
+function normalizeSearchText(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9_]+/g, "");
+}
+function scoreSearchResult(query, name, kind) {
+  if (!query) return 1;
+  const normalizedName = normalizeSearchText(name);
+  if (normalizedName === query) return 100;
+  if (normalizedName.startsWith(query)) return 75;
+  if (normalizedName.includes(query)) return 50;
+  const kindScore = kind.includes(query) ? 10 : 0;
+  return kindScore;
+}
+function toCreatorDocsUrl(kind, name) {
+  return `https://create.roblox.com/docs/reference/engine/${KIND_FOLDERS[kind]}/${name}`;
+}
+async function fetchText(url) {
+  const response = await fetch(url, {
+    headers: { "User-Agent": "Dominus Roblox API docs lookup" }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  return response.text();
+}
+function readTopScalar(raw, key) {
+  const lines = raw.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(new RegExp(`^${escapeRegExp(key)}:\\s*(.*)$`));
+    if (!match) continue;
+    return readYamlValue(lines, i, 0, match[1]);
+  }
+  return "";
+}
+function readTopList(raw, key) {
+  const lines = raw.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(new RegExp(`^${escapeRegExp(key)}:\\s*(.*)$`));
+    if (!match) continue;
+    const inline = match[1].trim();
+    if (inline === "[]" || inline === "") {
+      if (inline === "[]") return [];
+      return readIndentedList(lines, i + 1, 2);
+    }
+    return [unquote(inline)];
+  }
+  return [];
+}
+function parseMemberSection(raw, section) {
+  const sectionLines = extractTopSection(raw, section);
+  if (sectionLines.length === 0) return [];
+  const items = splitMemberItems(sectionLines);
+  return items.map((item) => parseMemberItem(item, section)).filter((item) => Boolean(item));
+}
+function extractTopSection(raw, section) {
+  const lines = raw.split(/\r?\n/);
+  const start = lines.findIndex((line) => line === `${section}:`);
+  if (start === -1) return [];
+  const result = [];
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^[A-Za-z_][A-Za-z0-9_]*:/.test(lines[i])) break;
+    result.push(lines[i]);
+  }
+  return result;
+}
+function splitMemberItems(lines) {
+  const items = [];
+  let current = [];
+  for (const line of lines) {
+    if (/^  - /.test(line)) {
+      if (current.length > 0) items.push(current);
+      current = [line];
+      continue;
+    }
+    if (current.length > 0) current.push(line);
+  }
+  if (current.length > 0) items.push(current);
+  return items;
+}
+function parseMemberItem(lines, section) {
+  const name = readMemberScalar(lines, "name");
+  if (!name) return null;
+  const member = {
+    name,
+    memberType: section,
+    type: readMemberScalar(lines, "type") || readMemberScalar(lines, "return_type"),
+    summary: cleanDocText(readMemberScalar(lines, "summary")),
+    description: cleanDocText(readMemberScalar(lines, "description")),
+    parameters: readNestedObjects(lines, "parameters"),
+    returns: readNestedObjects(lines, "returns"),
+    tags: readMemberList(lines, "tags"),
+    security: readSecurity(lines),
+    threadSafety: readMemberScalar(lines, "thread_safety"),
+    category: readMemberScalar(lines, "category"),
+    deprecationMessage: cleanDocText(readMemberScalar(lines, "deprecation_message"))
+  };
+  const value = Number(readMemberScalar(lines, "value"));
+  if (Number.isFinite(value)) member.value = value;
+  return member;
+}
+function readMemberScalar(lines, key) {
+  for (let i = 0; i < lines.length; i++) {
+    const firstLinePattern = new RegExp(`^  - ${escapeRegExp(key)}:\\s*(.*)$`);
+    const fieldPattern = new RegExp(`^    ${escapeRegExp(key)}:\\s*(.*)$`);
+    const firstLineMatch = lines[i].match(firstLinePattern);
+    const fieldMatch = lines[i].match(fieldPattern);
+    const match = firstLineMatch ?? fieldMatch;
+    if (!match) continue;
+    return readYamlValue(lines, i, firstLineMatch ? 2 : 4, match[1]);
+  }
+  return "";
+}
+function readMemberList(lines, key) {
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(new RegExp(`^    ${escapeRegExp(key)}:\\s*(.*)$`));
+    if (!match) continue;
+    const inline = match[1].trim();
+    if (inline === "[]") return [];
+    if (inline) return [unquote(inline)];
+    return readIndentedList(lines, i + 1, 6);
+  }
+  return [];
+}
+function readNestedObjects(lines, key) {
+  const start = lines.findIndex((line) => line === `    ${key}:`);
+  if (start === -1) return [];
+  const nested = [];
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^    [A-Za-z_][A-Za-z0-9_]*:/.test(lines[i])) break;
+    nested.push(lines[i]);
+  }
+  const items = [];
+  let current = [];
+  for (const line of nested) {
+    if (/^      - /.test(line)) {
+      if (current.length > 0) items.push(current);
+      current = [line];
+      continue;
+    }
+    if (current.length > 0) current.push(line);
+  }
+  if (current.length > 0) items.push(current);
+  return items.map((item) => ({
+    name: readNestedScalar(item, "name"),
+    type: readNestedScalar(item, "type"),
+    summary: cleanDocText(readNestedScalar(item, "summary")),
+    default: readNestedScalar(item, "default")
+  }));
+}
+function readNestedScalar(lines, key) {
+  for (let i = 0; i < lines.length; i++) {
+    const firstLinePattern = new RegExp(`^      - ${escapeRegExp(key)}:\\s*(.*)$`);
+    const fieldPattern = new RegExp(`^        ${escapeRegExp(key)}:\\s*(.*)$`);
+    const firstLineMatch = lines[i].match(firstLinePattern);
+    const fieldMatch = lines[i].match(fieldPattern);
+    const match = firstLineMatch ?? fieldMatch;
+    if (!match) continue;
+    return readYamlValue(lines, i, firstLineMatch ? 6 : 8, match[1]);
+  }
+  return "";
+}
+function readSecurity(lines) {
+  const start = lines.findIndex((line) => line === "    security:");
+  if (start === -1) return void 0;
+  return {
+    read: readIndentedScalar(lines, start + 1, "read", 6),
+    write: readIndentedScalar(lines, start + 1, "write", 6)
+  };
+}
+function readIndentedScalar(lines, start, key, indent) {
+  const pattern = new RegExp(`^\\s{${indent}}${escapeRegExp(key)}:\\s*(.*)$`);
+  for (let i = start; i < lines.length; i++) {
+    if (indentOf(lines[i]) < indent) break;
+    const match = lines[i].match(pattern);
+    if (match) return unquote(match[1].trim());
+  }
+  return "";
+}
+function readYamlValue(lines, index, indent, rawValue) {
+  const value = rawValue.trim();
+  if (value === "|-" || value === "|") {
+    return readBlock(lines, index + 1, indent + 2);
+  }
+  if (value === "''" || value === '""') return "";
+  return unquote(value);
+}
+function readBlock(lines, start, minIndent) {
+  const block = [];
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() && indentOf(line) < minIndent) break;
+    block.push(line.slice(Math.min(minIndent, line.length)));
+  }
+  return block.join("\n").trim();
+}
+function readIndentedList(lines, start, indent) {
+  const pattern = new RegExp(`^\\s{${indent}}-\\s*(.*)$`);
+  const values = [];
+  for (let i = start; i < lines.length; i++) {
+    if (lines[i].trim() && indentOf(lines[i]) < indent) break;
+    const match = lines[i].match(pattern);
+    if (match) values.push(unquote(match[1].trim()));
+  }
+  return values;
+}
+function cleanDocText(value) {
+  return value.replace(/\r/g, "").replace(/[ \t]+\n/g, "\n").trim();
+}
+function indentOf(line) {
+  return line.match(/^ */)?.[0].length ?? 0;
+}
+function unquote(value) {
+  if (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var GITHUB_RAW_BASE, GITHUB_TREE_URL, KIND_FOLDERS, MEMBER_SECTIONS, remoteTreeCache;
+var init_roblox_api = __esm({
+  "src/docs/roblox-api.ts"() {
+    GITHUB_RAW_BASE = "https://raw.githubusercontent.com/Roblox/creator-docs/main/content/en-us/reference/engine";
+    GITHUB_TREE_URL = "https://api.github.com/repos/Roblox/creator-docs/git/trees/main?recursive=1";
+    KIND_FOLDERS = {
+      class: "classes",
+      datatype: "datatypes",
+      enum: "enums",
+      global: "globals",
+      library: "libraries"
+    };
+    MEMBER_SECTIONS = [
+      "properties",
+      "methods",
+      "events",
+      "callbacks",
+      "constructors",
+      "functions",
+      "items",
+      "constants",
+      "math_operations"
+    ];
+    remoteTreeCache = null;
+  }
+});
+
+// src/tools/studio/read-script.ts
+var read_script_exports = {};
+__export(read_script_exports, {
+  tool: () => tool
+});
+var tool;
+var init_read_script = __esm({
+  "src/tools/studio/read-script.ts"() {
+    init_protocol();
+    tool = {
+      name: "read_script",
+      description: 'Read the source code of a script in Roblox Studio. Provide the full instance path (e.g., "ServerScriptService.GameManager").',
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: 'Full instance path of the script (e.g., "ServerScriptService.GameManager")'
+          }
+        },
+        required: ["path"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const path4 = params.path;
+        const response = await ctx.sendToStudio(CliMsg.GET_SCRIPT, { path: path4 });
+        if (!response.payload) {
+          return { success: false, error: `Script not found: ${path4}` };
+        }
+        return {
+          success: true,
+          data: {
+            path: response.payload.path,
+            className: response.payload.className,
+            source: response.payload.source,
+            lineCount: response.payload.lineCount
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/studio/edit-script.ts
+var edit_script_exports = {};
+__export(edit_script_exports, {
+  tool: () => tool2
+});
+var tool2;
+var init_edit_script = __esm({
+  "src/tools/studio/edit-script.ts"() {
+    init_protocol();
+    tool2 = {
+      name: "edit_script",
+      description: "Replace the entire source code of a script in Roblox Studio. Provide the full path and the new source code.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Full instance path of the script"
+          },
+          source: {
+            type: "string",
+            description: "The new complete source code for the script"
+          }
+        },
+        required: ["path", "source"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const path4 = params.path;
+        const source = params.source;
+        const response = await ctx.sendToStudio(CliMsg.SET_SCRIPT, { path: path4, source });
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Failed to edit script" };
+        }
+        return { success: true, data: { path: path4, linesWritten: source.split("\n").length } };
+      }
+    };
+  }
+});
+
+// src/tools/studio/run-code.ts
+var run_code_exports = {};
+__export(run_code_exports, {
+  tool: () => tool3
+});
+var tool3;
+var init_run_code = __esm({
+  "src/tools/studio/run-code.ts"() {
+    init_protocol();
+    tool3 = {
+      name: "run_code",
+      description: "Execute arbitrary Luau code in Roblox Studio and return the output. The code runs in the Studio plugin context with full API access.",
+      parameters: {
+        type: "object",
+        properties: {
+          code: {
+            type: "string",
+            description: "Luau code to execute in Studio"
+          }
+        },
+        required: ["code"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const code = params.code;
+        const response = await ctx.sendToStudio(CliMsg.RUN_CODE, { code });
+        const payload = response.payload;
+        if (payload.error) {
+          return { success: false, error: payload.error, data: { output: payload.output } };
+        }
+        return {
+          success: true,
+          data: { output: payload.output, duration: payload.duration }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/studio/get-explorer.ts
+var get_explorer_exports = {};
+__export(get_explorer_exports, {
+  tool: () => tool4
+});
+var tool4;
+var init_get_explorer = __esm({
+  "src/tools/studio/get-explorer.ts"() {
+    init_protocol();
+    tool4 = {
+      name: "get_explorer",
+      description: "Get the DataModel explorer tree from Roblox Studio. Optionally filter by a root path and max depth.",
+      parameters: {
+        type: "object",
+        properties: {
+          rootPath: {
+            type: "string",
+            description: 'Root path to start from (e.g., "ServerScriptService"). Omit for entire tree.'
+          },
+          maxDepth: {
+            type: "number",
+            description: "Maximum depth of the tree (default: 3)",
+            default: 3
+          }
+        }
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.GET_EXPLORER, {
+          rootPath: params.rootPath ?? null,
+          maxDepth: params.maxDepth ?? 3
+        });
+        return { success: true, data: response.payload };
+      }
+    };
+  }
+});
+
+// src/tools/studio/get-properties.ts
+var get_properties_exports = {};
+__export(get_properties_exports, {
+  tool: () => tool5
+});
+var tool5;
+var init_get_properties = __esm({
+  "src/tools/studio/get-properties.ts"() {
+    init_protocol();
+    tool5 = {
+      name: "get_properties",
+      description: "Get all properties of a single instance in Roblox Studio. By default uses compact mode which strips read-only, nil, deprecated, and default-valued properties. For inspecting UI trees, prefer serialize_ui or get_descendants_properties.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: 'Full instance path (e.g., "Workspace.Part")'
+          },
+          compact: {
+            type: "boolean",
+            description: "Strip read-only, nil, deprecated, and default-valued properties (default true). Set false for full dump."
+          }
+        },
+        required: ["path"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const compact = params.compact !== false;
+        const response = await ctx.sendToStudio(
+          CliMsg.GET_PROPERTIES,
+          { path: params.path, compact }
+        );
+        return { success: true, data: response.payload };
+      }
+    };
+  }
+});
+
+// src/tools/studio/get-descendants-properties.ts
+var get_descendants_properties_exports = {};
+__export(get_descendants_properties_exports, {
+  tool: () => tool6
+});
+var tool6;
+var init_get_descendants_properties = __esm({
+  "src/tools/studio/get-descendants-properties.ts"() {
+    init_protocol();
+    tool6 = {
+      name: "get_descendants_properties",
+      description: "Easily get all descendants of a UI instance (or any instance) and all of their properties. By default uses compact mode which strips read-only, nil, deprecated, and default-valued properties to keep responses small.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: 'Full instance path (e.g., "Workspace.Part", "StarterGui.ScreenGui")'
+          },
+          compact: {
+            type: "boolean",
+            description: "When true (default), strips read-only, nil, deprecated, and default-valued properties to massively reduce response size. Set to false for full property dump."
+          },
+          outputFile: {
+            type: "string",
+            description: "Optional file path to write the JSON result to, useful for very large trees where context limits apply."
+          }
+        },
+        required: ["path"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const compact = params.compact !== false;
+        const response = await ctx.sendToStudio(
+          CliMsg.GET_DESCENDANTS_PROPERTIES,
+          { path: params.path, compact },
+          1e3 * 60 * 5
+          // 5 minute timeout since getting ALL descendants can take a very long time
+        );
+        if (params.outputFile && typeof params.outputFile === "string") {
+          const fs5 = await import('fs/promises');
+          const path4 = await import('path');
+          const outputPath = path4.resolve(process.cwd(), params.outputFile);
+          await fs5.writeFile(outputPath, JSON.stringify(response.payload, null, 2), "utf-8");
+          return { success: true, data: `Successfully saved descendants to ${outputPath}` };
+        }
+        return { success: true, data: response.payload };
+      }
+    };
+  }
+});
+
+// src/tools/studio/set-properties.ts
+var set_properties_exports = {};
+__export(set_properties_exports, {
+  tool: () => tool7
+});
+var tool7;
+var init_set_properties = __esm({
+  "src/tools/studio/set-properties.ts"() {
+    init_protocol();
+    tool7 = {
+      name: "set_properties",
+      description: "Set properties on an instance in Roblox Studio.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: 'Full instance path (e.g., "Workspace.Part")'
+          },
+          properties: {
+            type: "object",
+            description: 'Key-value pairs of properties to set (e.g., {"Name": "MyPart", "BrickColor": "Bright red"})'
+          }
+        },
+        required: ["path", "properties"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.SET_PROPERTIES, {
+          path: params.path,
+          properties: params.properties
+        });
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Failed to set properties" };
+        }
+        return { success: true, data: { path: params.path, updated: Object.keys(params.properties) } };
+      }
+    };
+  }
+});
+
+// src/tools/studio/insert-instance.ts
+var insert_instance_exports = {};
+__export(insert_instance_exports, {
+  tool: () => tool8
+});
+var tool8;
+var init_insert_instance = __esm({
+  "src/tools/studio/insert-instance.ts"() {
+    init_protocol();
+    tool8 = {
+      name: "insert_instance",
+      description: "Insert a new instance into the Roblox Studio DataModel.",
+      parameters: {
+        type: "object",
+        properties: {
+          className: {
+            type: "string",
+            description: 'Class name of the instance to create (e.g., "Part", "Script", "ModuleScript")'
+          },
+          parentPath: {
+            type: "string",
+            description: 'Full path of the parent instance (e.g., "Workspace", "ServerScriptService")'
+          },
+          name: {
+            type: "string",
+            description: "Name for the new instance"
+          },
+          properties: {
+            type: "object",
+            description: "Optional properties to set on the new instance"
+          }
+        },
+        required: ["className", "parentPath", "name"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.INSERT_INSTANCE, {
+          className: params.className,
+          parentPath: params.parentPath,
+          name: params.name,
+          properties: params.properties ?? {}
+        });
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Failed to insert instance" };
+        }
+        return { success: true, data: { path: payload.path } };
+      }
+    };
+  }
+});
+
+// src/tools/studio/delete-instance.ts
+var delete_instance_exports = {};
+__export(delete_instance_exports, {
+  tool: () => tool9
+});
+var tool9;
+var init_delete_instance = __esm({
+  "src/tools/studio/delete-instance.ts"() {
+    init_protocol();
+    tool9 = {
+      name: "delete_instance",
+      description: "Delete an instance from the Roblox Studio DataModel by path.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: 'Full instance path to delete (e.g., "Workspace.OldPart")'
+          }
+        },
+        required: ["path"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.DELETE_INSTANCE, { path: params.path });
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Failed to delete instance" };
+        }
+        return { success: true, data: { deleted: params.path } };
+      }
+    };
+  }
+});
+
+// src/tools/studio/get-output.ts
+var get_output_exports = {};
+__export(get_output_exports, {
+  tool: () => tool10
+});
+var tool10;
+var init_get_output = __esm({
+  "src/tools/studio/get-output.ts"() {
+    init_protocol();
+    tool10 = {
+      name: "get_output",
+      description: "Get recent output log entries from Roblox Studio (prints, warnings, errors).",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: {
+            type: "number",
+            description: "Maximum number of log entries to return (default: 50)",
+            default: 50
+          },
+          level: {
+            type: "string",
+            description: "Filter by log level",
+            enum: ["info", "warn", "error"]
+          }
+        }
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.GET_OUTPUT, {
+          limit: params.limit ?? 50,
+          level: params.level ?? null
+        });
+        return { success: true, data: response.payload };
+      }
+    };
+  }
+});
+
+// src/tools/studio/get-selection.ts
+var get_selection_exports = {};
+__export(get_selection_exports, {
+  tool: () => tool11
+});
+var tool11;
+var init_get_selection = __esm({
+  "src/tools/studio/get-selection.ts"() {
+    init_protocol();
+    tool11 = {
+      name: "get_selection",
+      description: "Get the currently selected instances in Roblox Studio.",
+      parameters: {
+        type: "object",
+        properties: {}
+      },
+      async execute(_params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.GET_SELECTION, {});
+        return { success: true, data: response.payload };
+      }
+    };
+  }
+});
+
+// src/tools/studio/search-scripts.ts
+var search_scripts_exports = {};
+__export(search_scripts_exports, {
+  tool: () => tool12
+});
+var tool12;
+var init_search_scripts = __esm({
+  "src/tools/studio/search-scripts.ts"() {
+    init_protocol();
+    tool12 = {
+      name: "search_scripts",
+      description: "Search across all scripts in Roblox Studio for a text pattern. Returns matching lines with context.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Text or pattern to search for in script sources"
+          },
+          maxResults: {
+            type: "number",
+            description: "Maximum number of script results (default: 20)",
+            default: 20
+          }
+        },
+        required: ["query"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.SEARCH_SCRIPTS, {
+          query: params.query,
+          maxResults: params.maxResults ?? 20
+        });
+        return { success: true, data: response.payload };
+      }
+    };
+  }
+});
+
+// src/tools/studio/run-tests.ts
+var run_tests_exports = {};
+__export(run_tests_exports, {
+  tool: () => tool13
+});
+var tool13;
+var init_run_tests = __esm({
+  "src/tools/studio/run-tests.ts"() {
+    init_protocol();
+    tool13 = {
+      name: "run_tests",
+      description: "Run tests in Roblox Studio using StudioTestService. Can run all tests or a specific test by name.",
+      parameters: {
+        type: "object",
+        properties: {
+          testName: {
+            type: "string",
+            description: "Specific test name to run. Omit to run all tests."
+          }
+        }
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.RUN_TESTS, {
+          testName: params.testName ?? null
+        });
+        const results = response.payload.results ?? [];
+        const passed = results.filter((r) => r.passed).length;
+        const failed = results.filter((r) => !r.passed).length;
+        return {
+          success: failed === 0,
+          data: { total: results.length, passed, failed, results }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/studio/get-class-info.ts
+var get_class_info_exports = {};
+__export(get_class_info_exports, {
+  tool: () => tool14
+});
+var tool14;
+var init_get_class_info = __esm({
+  "src/tools/studio/get-class-info.ts"() {
+    init_protocol();
+    tool14 = {
+      name: "get_class_info",
+      description: "Look up the full schema of a Roblox class using ReflectionService. Returns all properties (with their types), methods (with parameters), and events. ALWAYS call this before creating or modifying GUI/UI elements (Frame, TextLabel, ImageLabel, etc.) to know the correct property names and expected types (e.g., Size is UDim2 for GUI, Vector3 for Parts).",
+      parameters: {
+        type: "object",
+        properties: {
+          className: {
+            type: "string",
+            description: 'Roblox class name, e.g. "Frame", "TextLabel", "Part", "MeshPart", "Camera"'
+          }
+        },
+        required: ["className"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.GET_REFLECTION, { className: params.className });
+        const payload = response.payload;
+        if (payload.error) {
+          return { success: false, error: payload.error };
+        }
+        return { success: true, data: payload };
+      }
+    };
+  }
+});
+
+// src/tools/studio/create-ui.ts
+var create_ui_exports = {};
+__export(create_ui_exports, {
+  tool: () => tool15
+});
+var tool15;
+var init_create_ui = __esm({
+  "src/tools/studio/create-ui.ts"() {
+    init_protocol();
+    tool15 = {
+      name: "create_ui",
+      description: 'Create an entire UI tree in Roblox Studio in a SINGLE call. Pass a declarative JSON tree with ClassName, Name, properties, and Children. All types are auto-coerced natively in Luau \u2014 UDim2, Color3, Font, enums all work. This is 10x faster than run_code for UI because it handles everything in one round-trip with no Luau syntax issues. Replaces any existing instance with the same name.\n\nExample: create a pastel hello world screen:\n{\n  "parent": "StarterGui",\n  "tree": {\n    "ClassName": "ScreenGui",\n    "Name": "HelloWorld",\n    "ResetOnSpawn": false,\n    "Children": [{\n      "ClassName": "Frame",\n      "Name": "Background",\n      "Size": [1, 0, 1, 0],\n      "BackgroundColor3": "#F0E6FF",\n      "Children": [\n        { "ClassName": "UICorner", "CornerRadius": [0, 12] },\n        { "ClassName": "TextLabel", "Name": "Title", "Text": "Hello World!",\n          "Size": [0.5, 0, 0.1, 0], "Position": [0.25, 0, 0.45, 0],\n          "BackgroundTransparency": 1, "TextColor3": "#6C5CE7",\n          "TextScaled": true, "Font": "GothamBold" }\n      ]\n    }]\n  }\n}',
+      parameters: {
+        type: "object",
+        properties: {
+          parent: {
+            type: "string",
+            description: 'Parent path: "StarterGui", "PlayerGui", or any instance path. Default: StarterGui'
+          },
+          tree: {
+            type: "object",
+            description: 'The root UI node. Each node has: ClassName (string), Name (string), Children (array of child nodes), and properties. Properties may be specified either flattened at the top level of the node, OR nested under a "properties" / "Properties" / "props" key \u2014 both work. Property values are auto-coerced:\n  UDim2: [xScale, xOffset, yScale, yOffset] or {XScale, XOffset, YScale, YOffset}\n  Color3: "#hex", "rgb(r,g,b)", [r,g,b], or BrickColor name\n  UDim: [scale, offset] or number\n  Vector2: [x, y] or {x, y} (auto-disambiguated from UDim by property name)\n  NumberRange: [min, max] or number\n  Rect: [minX, minY, maxX, maxY] or {MinX, MinY, MaxX, MaxY}\n  Font: "GothamBold", "SourceSans", etc. (Enum.Font names)\n  Enums: string name like "Center", "Left", "Fit"\n  FontFace: {Family, Weight, Style}\n  2-element arrays are auto-disambiguated: AnchorPoint\u2192Vector2, CornerRadius/Padding\u2192UDim, etc.'
+          },
+          animate: {
+            type: "boolean",
+            description: "If true, task.wait() will be injected between creation of nodes so that the UI writes out dynamically."
+          }
+        },
+        required: ["tree"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.BUILD_UI, {
+          parent: params.parent ?? "StarterGui",
+          animate: params.animate,
+          tree: params.tree
+        });
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "UI build failed" };
+        }
+        return {
+          success: true,
+          data: { path: payload.path, instanceCount: payload.instanceCount }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/studio/execute-run-test.ts
+var execute_run_test_exports = {};
+__export(execute_run_test_exports, {
+  tool: () => tool16
+});
+var tool16;
+var init_execute_run_test = __esm({
+  "src/tools/studio/execute-run-test.ts"() {
+    init_protocol();
+    tool16 = {
+      name: "execute_run_test",
+      description: "Start a Run mode test session in Roblox Studio using StudioTestService:ExecuteRunModeAsync(). Passes args that server scripts can retrieve via GetTestArgs(). Yields until the session ends (via EndTest or manual stop). Returns the value passed to EndTest(). Use this for headless automated tests \u2014 no player character, just server scripts running.",
+      parameters: {
+        type: "object",
+        properties: {
+          args: {
+            description: "Arguments to pass to the test session. Server scripts retrieve this with StudioTestService:GetTestArgs(). Can be a string (e.g. test suite name), table, or any serializable value."
+          }
+        }
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(
+          CliMsg.EXECUTE_RUN_TEST,
+          { args: params.args ?? null },
+          12e4
+        );
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Run mode test failed" };
+        }
+        return {
+          success: true,
+          data: {
+            result: payload.result,
+            duration: payload.duration
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/studio/execute-play-test.ts
+var execute_play_test_exports = {};
+__export(execute_play_test_exports, {
+  tool: () => tool17
+});
+var tool17;
+var init_execute_play_test = __esm({
+  "src/tools/studio/execute-play-test.ts"() {
+    init_protocol();
+    tool17 = {
+      name: "execute_play_test",
+      description: "Start a solo Play mode test session in Roblox Studio using StudioTestService:ExecutePlayModeAsync(). Passes args that server scripts can retrieve via GetTestArgs(). Yields until the session ends (via EndTest or manual stop). Returns the value passed to EndTest(). Use this for tests that need a player character and full client-server simulation.",
+      parameters: {
+        type: "object",
+        properties: {
+          args: {
+            description: "Arguments to pass to the test session. Server scripts retrieve this with StudioTestService:GetTestArgs(). Can be a string (e.g. test suite name), table, or any serializable value."
+          }
+        }
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(
+          CliMsg.EXECUTE_PLAY_TEST,
+          { args: params.args ?? null },
+          12e4
+        );
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Play mode test failed" };
+        }
+        return {
+          success: true,
+          data: {
+            result: payload.result,
+            duration: payload.duration
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/studio/create-part.ts
+var create_part_exports = {};
+__export(create_part_exports, {
+  tool: () => tool18
+});
+var tool18;
+var init_create_part = __esm({
+  "src/tools/studio/create-part.ts"() {
+    init_protocol();
+    tool18 = {
+      name: "create_part",
+      description: "Create a Part in Roblox Studio with position, size, color, material and more \u2014 all in one call. Much faster than insert_instance + set_properties separately.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Name for the part" },
+          parent: {
+            type: "string",
+            description: 'Parent path (default: "Workspace")'
+          },
+          shape: {
+            type: "string",
+            enum: ["Block", "Ball", "Cylinder", "Wedge", "CornerWedge"],
+            description: "Part shape (default: Block)"
+          },
+          position: {
+            type: "object",
+            properties: { x: { type: "number" }, y: { type: "number" }, z: { type: "number" } },
+            description: "World position {x, y, z}"
+          },
+          size: {
+            type: "object",
+            properties: { x: { type: "number" }, y: { type: "number" }, z: { type: "number" } },
+            description: "Size in studs {x, y, z} (default: {4, 1, 2})"
+          },
+          color: {
+            type: "string",
+            description: 'Color as hex "#FF0000", BrickColor name "Bright red", or RGB "rgb(255,0,0)"'
+          },
+          material: {
+            type: "string",
+            description: "Material name: Plastic, Wood, Grass, Ice, Metal, Concrete, Sand, Neon, Glass, etc."
+          },
+          transparency: { type: "number", description: "0 (opaque) to 1 (invisible)" },
+          anchored: { type: "boolean", description: "Whether the part is anchored (default: true)" },
+          canCollide: { type: "boolean", description: "Whether the part has collision" }
+        },
+        required: ["name"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const parent = params.parent || "Workspace";
+        const name = params.name;
+        const pos = params.position;
+        const size = params.size;
+        const properties = {};
+        if (pos) properties.Position = { X: pos.x ?? 0, Y: pos.y ?? 0, Z: pos.z ?? 0 };
+        if (size) properties.Size = { X: size.x ?? 4, Y: size.y ?? 1, Z: size.z ?? 2 };
+        if (params.color) {
+          const c = params.color;
+          if (c.startsWith("#")) {
+            properties.Color = c;
+          } else if (c.startsWith("rgb")) {
+            const m = c.match(/(\d+)/g);
+            if (m && m.length >= 3) {
+              properties.Color = { red: parseInt(m[0]), green: parseInt(m[1]), blue: parseInt(m[2]) };
+            }
+          } else {
+            properties.BrickColor = c;
+          }
+        }
+        if (params.material) properties.Material = params.material;
+        if (params.transparency !== void 0) properties.Transparency = params.transparency;
+        if (params.anchored !== void 0) properties.Anchored = params.anchored;
+        else properties.Anchored = true;
+        if (params.canCollide !== void 0) properties.CanCollide = params.canCollide;
+        if (params.shape && params.shape !== "Block") properties.Shape = params.shape;
+        const className = params.shape === "Wedge" ? "WedgePart" : params.shape === "CornerWedge" ? "CornerWedgePart" : "Part";
+        const res = await ctx.sendToStudio(CliMsg.INSERT_INSTANCE, {
+          className,
+          parentPath: parent,
+          name,
+          properties
+        });
+        const payload = res.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Failed to create part" };
+        }
+        return {
+          success: true,
+          data: { path: payload.path, properties: Object.keys(properties) }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/studio/clone-instance.ts
+var clone_instance_exports = {};
+__export(clone_instance_exports, {
+  tool: () => tool19
+});
+function buildCloneCode(params) {
+  const path4 = params.path;
+  const parts = path4.split(".");
+  let resolve = "game";
+  for (const p of parts) {
+    resolve += `["${p}"]`;
+  }
+  const lines = [
+    `local orig = ${resolve}`,
+    `local clone = orig:Clone()`
+  ];
+  if (params.newName) {
+    lines.push(`clone.Name = "${params.newName}"`);
+  }
+  if (params.newParent) {
+    const parentParts = params.newParent.split(".");
+    let parentResolve = "game";
+    for (const p of parentParts) {
+      parentResolve += `["${p}"]`;
+    }
+    lines.push(`clone.Parent = ${parentResolve}`);
+  } else {
+    lines.push(`clone.Parent = orig.Parent`);
+  }
+  const offset = params.offset;
+  if (offset) {
+    lines.push(`if clone:IsA("BasePart") then`);
+    lines.push(`  clone.Position = clone.Position + Vector3.new(${offset.x ?? 0}, ${offset.y ?? 0}, ${offset.z ?? 0})`);
+    lines.push(`end`);
+  }
+  lines.push(`print("Cloned: " .. clone:GetFullName())`);
+  return lines.join("\n");
+}
+var tool19;
+var init_clone_instance = __esm({
+  "src/tools/studio/clone-instance.ts"() {
+    init_protocol();
+    tool19 = {
+      name: "clone_instance",
+      description: "Clone an existing instance in Roblox Studio and optionally reposition/rename it. Great for duplicating parts, models, or entire trees.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Path of instance to clone" },
+          newName: { type: "string", description: "Name for the clone (optional)" },
+          newParent: { type: "string", description: "Parent path for the clone (optional, defaults to same parent)" },
+          offset: {
+            type: "object",
+            properties: { x: { type: "number" }, y: { type: "number" }, z: { type: "number" } },
+            description: "Position offset from original {x, y, z}"
+          }
+        },
+        required: ["path"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const code = buildCloneCode(params);
+        const res = await ctx.sendToStudio(CliMsg.RUN_CODE, { code });
+        const payload = res.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Failed to clone" };
+        }
+        return { success: true, data: { output: payload.output } };
+      }
+    };
+  }
+});
+
+// src/tools/studio/group-instances.ts
+var group_instances_exports = {};
+__export(group_instances_exports, {
+  tool: () => tool20
+});
+var tool20;
+var init_group_instances = __esm({
+  "src/tools/studio/group-instances.ts"() {
+    init_protocol();
+    tool20 = {
+      name: "group_instances",
+      description: 'Group multiple instances under a new Model or Folder. Useful for organizing parts into objects (e.g., grouping trunk + leaves into a "Tree" model).',
+      parameters: {
+        type: "object",
+        properties: {
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Array of instance paths to group together"
+          },
+          groupName: { type: "string", description: "Name for the new group" },
+          groupClass: {
+            type: "string",
+            enum: ["Model", "Folder"],
+            description: "Class for the group container (default: Model)"
+          },
+          parent: { type: "string", description: "Parent path (default: Workspace)" }
+        },
+        required: ["paths", "groupName"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const paths = params.paths;
+        const groupName = params.groupName;
+        const groupClass = params.groupClass || "Model";
+        const parent = params.parent || "Workspace";
+        const resolves = paths.map((p) => {
+          const parts = p.split(".");
+          let r = "game";
+          for (const part of parts) r += `["${part}"]`;
+          return r;
+        });
+        const parentParts = parent.split(".");
+        let parentResolve = "game";
+        for (const p of parentParts) parentResolve += `["${p}"]`;
+        const code = [
+          `local group = Instance.new("${groupClass}")`,
+          `group.Name = "${groupName}"`,
+          `group.Parent = ${parentResolve}`,
+          ...resolves.map((r) => `${r}.Parent = group`),
+          groupClass === "Model" ? `if group:IsA("Model") then group:MoveTo(group:GetBoundingBox().Position) end` : "",
+          `print("Grouped ${paths.length} instances into: " .. group:GetFullName())`
+        ].filter(Boolean).join("\n");
+        const res = await ctx.sendToStudio(CliMsg.RUN_CODE, { code });
+        const payload = res.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Failed to group" };
+        }
+        return { success: true, data: { groupPath: `${parent}.${groupName}`, count: paths.length } };
+      }
+    };
+  }
+});
+
+// src/tools/studio/build-multiple.ts
+var build_multiple_exports = {};
+__export(build_multiple_exports, {
+  tool: () => tool21
+});
+function generateBatchCode(parts, groupName, groupParent) {
+  const lines = [];
+  function resolveParent(path4) {
+    const segs = path4.split(".");
+    let r = "game";
+    for (const s of segs) r += `["${s}"]`;
+    return r;
+  }
+  if (groupName) {
+    const gp = resolveParent(groupParent);
+    lines.push(`local _group = Instance.new("Model")`);
+    lines.push(`_group.Name = "${groupName}"`);
+    lines.push(`_group.Parent = ${gp}`);
+  }
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    const varName = `_p${i}`;
+    const cn = p.className || (p.shape === "Wedge" ? "WedgePart" : "Part");
+    lines.push(`local ${varName} = Instance.new("${cn}")`);
+    lines.push(`${varName}.Name = "${p.name}"`);
+    if (p.position) {
+      lines.push(`${varName}.Position = Vector3.new(${p.position.x ?? 0}, ${p.position.y ?? 0}, ${p.position.z ?? 0})`);
+    }
+    if (p.size) {
+      lines.push(`${varName}.Size = Vector3.new(${p.size.x ?? 4}, ${p.size.y ?? 1}, ${p.size.z ?? 2})`);
+    }
+    if (p.color) {
+      if (p.color.startsWith("#")) {
+        lines.push(`${varName}.Color = Color3.fromHex("${p.color}")`);
+      } else {
+        lines.push(`${varName}.BrickColor = BrickColor.new("${p.color}")`);
+      }
+    }
+    if (p.material) {
+      lines.push(`${varName}.Material = Enum.Material.${p.material}`);
+    }
+    if (p.transparency !== void 0) {
+      lines.push(`${varName}.Transparency = ${p.transparency}`);
+    }
+    if (p.anchored !== void 0) {
+      lines.push(`${varName}.Anchored = ${p.anchored}`);
+    } else {
+      lines.push(`${varName}.Anchored = true`);
+    }
+    if (p.shape && p.shape !== "Block" && cn === "Part") {
+      lines.push(`${varName}.Shape = Enum.PartType.${p.shape}`);
+    }
+    if (groupName) {
+      lines.push(`${varName}.Parent = _group`);
+    } else {
+      const parent = p.parent || "Workspace";
+      lines.push(`${varName}.Parent = ${resolveParent(parent)}`);
+    }
+  }
+  lines.push(`print("Built ${parts.length} parts${groupName ? ` in ${groupName}` : ""}")`);
+  return lines.join("\n");
+}
+var tool21;
+var init_build_multiple = __esm({
+  "src/tools/studio/build-multiple.ts"() {
+    init_protocol();
+    tool21 = {
+      name: "build_multiple",
+      description: "Create multiple parts/instances in one batch call. Send an array of specs and they all get created in a single Studio round-trip. Ideal for building trees, houses, vehicles, terrain \u2014 anything composed of multiple parts.",
+      parameters: {
+        type: "object",
+        properties: {
+          parts: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string", description: "Part name" },
+                className: { type: "string", description: "ClassName (default: Part)" },
+                parent: { type: "string", description: "Parent path (default: Workspace)" },
+                position: {
+                  type: "object",
+                  properties: { x: { type: "number" }, y: { type: "number" }, z: { type: "number" } }
+                },
+                size: {
+                  type: "object",
+                  properties: { x: { type: "number" }, y: { type: "number" }, z: { type: "number" } }
+                },
+                color: { type: "string", description: 'Hex "#RRGGBB" or BrickColor name' },
+                material: { type: "string" },
+                transparency: { type: "number" },
+                anchored: { type: "boolean" },
+                shape: { type: "string", enum: ["Block", "Ball", "Cylinder", "Wedge"] }
+              },
+              required: ["name"]
+            },
+            description: "Array of part specifications"
+          },
+          groupName: {
+            type: "string",
+            description: "Optional: group all parts under a Model with this name"
+          },
+          groupParent: {
+            type: "string",
+            description: "Parent for the group Model (default: Workspace)"
+          }
+        },
+        required: ["parts"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const parts = params.parts;
+        const groupName = params.groupName;
+        const groupParent = params.groupParent || "Workspace";
+        const code = generateBatchCode(parts, groupName, groupParent);
+        const res = await ctx.sendToStudio(CliMsg.RUN_CODE, { code });
+        const payload = res.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Batch build failed" };
+        }
+        return {
+          success: true,
+          data: {
+            count: parts.length,
+            group: groupName ?? null,
+            output: payload.output
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/studio/serialize-ui.ts
+var serialize_ui_exports = {};
+__export(serialize_ui_exports, {
+  tool: () => tool22
+});
+var tool22;
+var init_serialize_ui = __esm({
+  "src/tools/studio/serialize-ui.ts"() {
+    init_protocol();
+    tool22 = {
+      name: "serialize_ui",
+      description: "Serialize an existing UI tree from Roblox Studio into create_ui-compatible JSON. This is the reverse of create_ui \u2014 read any instance and get back a declarative JSON tree you can modify and pass back to create_ui. Perfect for cloning, templating, or refactoring UIs.\n\nThe output includes ClassName, Name, all non-default properties (with values converted to JSON-friendly formats like [r,g,b] for Color3, [xS,xO,yS,yO] for UDim2, etc.), and Children.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: 'Instance path to serialize (e.g. "StarterGui.MyScreenGui")'
+          },
+          maxDepth: {
+            type: "number",
+            description: "Maximum depth to serialize (default: 50)"
+          }
+        },
+        required: ["path"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.SERIALIZE_UI, {
+          path: params.path,
+          maxDepth: params.maxDepth ?? 50
+        }, 1e3 * 60 * 2);
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Serialization failed" };
+        }
+        return { success: true, data: payload.tree };
+      }
+    };
+  }
+});
+
+// src/tools/studio/move-instance.ts
+var move_instance_exports = {};
+__export(move_instance_exports, {
+  tool: () => tool23
+});
+var tool23;
+var init_move_instance = __esm({
+  "src/tools/studio/move-instance.ts"() {
+    init_protocol();
+    tool23 = {
+      name: "move_instance",
+      description: "Move (reparent) an instance to a new parent in Roblox Studio. This preserves the instance and all its descendants \u2014 much better than delete + recreate. Sets a ChangeHistoryService waypoint so the move can be undone.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: 'Full path of the instance to move (e.g. "Workspace.OldFolder.MyPart")'
+          },
+          newParent: {
+            type: "string",
+            description: 'Full path of the new parent (e.g. "Workspace.NewFolder")'
+          }
+        },
+        required: ["path", "newParent"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.MOVE_INSTANCE, {
+          path: params.path,
+          newParent: params.newParent
+        });
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Move failed" };
+        }
+        return { success: true, data: { newPath: payload.newPath } };
+      }
+    };
+  }
+});
+
+// src/tools/studio/bulk-set-properties.ts
+var bulk_set_properties_exports = {};
+__export(bulk_set_properties_exports, {
+  tool: () => tool24
+});
+var tool24;
+var init_bulk_set_properties = __esm({
+  "src/tools/studio/bulk-set-properties.ts"() {
+    init_protocol();
+    tool24 = {
+      name: "bulk_set_properties",
+      description: 'Set properties on multiple instances at once in a single call. Much faster than calling set_properties repeatedly. Supports two modes:\n1. Explicit paths: provide an array of {path, properties} objects\n2. By class filter: provide a root path, className filter, and properties to apply to all matches\n\nFilter mode also supports addChildren: insert child instances (e.g. UIStroke, UICorner) on every match. Idempotent \u2014 skips if a child of that class already exists.\n\nExample (explicit): targets=[{"path": "StarterGui.HUD.Title", "properties": {"TextColor3": "#fff"}}]\nExample (filter): root="StarterGui.HUD", className="TextLabel", properties={"Font": "RobotoBold"}\nExample (addChildren): root="StarterGui.HUD", className="TextLabel", addChildren=[{"ClassName": "UIStroke", "Color": "#000000", "Thickness": 1.5}]',
+      parameters: {
+        type: "object",
+        properties: {
+          targets: {
+            type: "array",
+            description: "Array of {path, properties} objects for explicit mode.",
+            items: {
+              type: "object",
+              description: "A target with path and properties to set."
+            }
+          },
+          root: {
+            type: "string",
+            description: "Root instance path to search under (filter mode)"
+          },
+          className: {
+            type: "string",
+            description: "Only apply to instances of this ClassName (filter mode)"
+          },
+          properties: {
+            type: "object",
+            description: "Properties to set on all matched instances (filter mode)"
+          },
+          addChildren: {
+            type: "array",
+            description: "Child instances to insert on every match (filter mode). Each item: {ClassName, Name?, ...props}. Idempotent \u2014 skips if child of that class already exists.",
+            items: {
+              type: "object",
+              description: "Child instance spec with ClassName and properties"
+            }
+          }
+        }
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.BULK_SET_PROPERTIES, {
+          targets: params.targets,
+          root: params.root,
+          className: params.className,
+          properties: params.properties,
+          addChildren: params.addChildren
+        }, 1e3 * 60);
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Bulk set failed" };
+        }
+        return {
+          success: true,
+          data: {
+            modified: payload.modified,
+            errors: payload.errors?.length ? payload.errors : void 0
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/studio/find-replace-scripts.ts
+var find_replace_scripts_exports = {};
+__export(find_replace_scripts_exports, {
+  tool: () => tool25
+});
+var tool25;
+var init_find_replace_scripts = __esm({
+  "src/tools/studio/find-replace-scripts.ts"() {
+    init_protocol();
+    tool25 = {
+      name: "find_replace_scripts",
+      description: 'Find and replace text across all scripts in the game (or under a root path). Supports plain text and Lua pattern matching. Returns a list of modified scripts with match counts.\n\nUse dryRun=true to preview changes without applying them.\nExample: find="workspace" replace="Workspace" root="ServerScriptService"',
+      parameters: {
+        type: "object",
+        properties: {
+          find: {
+            type: "string",
+            description: "Text or Lua pattern to search for"
+          },
+          replace: {
+            type: "string",
+            description: "Replacement text (supports Lua pattern captures like %1, %2)"
+          },
+          root: {
+            type: "string",
+            description: "Root path to limit search scope (optional, searches entire game if omitted)"
+          },
+          usePattern: {
+            type: "boolean",
+            description: "If true, treat find/replace as Lua patterns. Default: false (plain text)"
+          },
+          dryRun: {
+            type: "boolean",
+            description: "If true, report matches but do not modify scripts. Default: false"
+          }
+        },
+        required: ["find", "replace"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.FIND_REPLACE_SCRIPTS, {
+          find: params.find,
+          replace: params.replace,
+          root: params.root,
+          usePattern: params.usePattern ?? false,
+          dryRun: params.dryRun ?? false
+        }, 1e3 * 60 * 5);
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Find/replace failed" };
+        }
+        return {
+          success: true,
+          data: {
+            totalFiles: payload.totalFiles,
+            totalMatches: payload.totalMatches,
+            modified: payload.modified,
+            dryRun: params.dryRun ?? false
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/docs/search-roblox-api.ts
+var search_roblox_api_exports = {};
+__export(search_roblox_api_exports, {
+  tool: () => tool26
+});
+var tool26;
+var init_search_roblox_api = __esm({
+  "src/tools/docs/search-roblox-api.ts"() {
+    init_roblox_api();
+    tool26 = {
+      name: "search_roblox_api",
+      description: "Search Roblox Creator Docs engine API reference names. Use this when you are unsure of an exact class, enum, datatype, global, or library name.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: 'Name fragment to search, e.g. "Text", "Run", "UDim", "FrameStyle"'
+          },
+          kind: {
+            type: "string",
+            description: "Optional reference kind filter.",
+            enum: ["any", "class", "datatype", "enum", "global", "library"],
+            default: "any"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum results to return (default: 10, max: 50)",
+            default: 10
+          }
+        },
+        required: ["query"]
+      },
+      async execute(params) {
+        try {
+          const results = await searchRobloxApi(String(params.query ?? ""), {
+            kind: params.kind ?? "any",
+            limit: params.limit ?? 10
+          });
+          return { success: true, data: { results } };
+        } catch (err) {
+          return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+    };
+  }
+});
+
+// src/tools/docs/get-roblox-api-reference.ts
+var get_roblox_api_reference_exports = {};
+__export(get_roblox_api_reference_exports, {
+  tool: () => tool27
+});
+var tool27;
+var init_get_roblox_api_reference = __esm({
+  "src/tools/docs/get-roblox-api-reference.ts"() {
+    init_roblox_api();
+    tool27 = {
+      name: "get_roblox_api_reference",
+      description: "Look up Roblox Creator Docs engine API reference for a class, datatype, enum, global, or library. Works without Studio connected and includes summaries, descriptions, tags, members, parameters, returns, security, and thread safety.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: 'API reference name, e.g. "Frame", "RunService", "UDim2", "FrameStyle", "task"'
+          },
+          kind: {
+            type: "string",
+            description: 'Optional reference kind. Use "any" to search all reference kinds.',
+            enum: ["any", "class", "datatype", "enum", "global", "library"],
+            default: "any"
+          },
+          includeInherited: {
+            type: "boolean",
+            description: "For classes, include members from inherited base classes (default: true).",
+            default: true
+          }
+        },
+        required: ["name"]
+      },
+      async execute(params) {
+        try {
+          const reference = await getRobloxApiReference(String(params.name ?? ""), {
+            kind: params.kind ?? "any",
+            includeInherited: params.includeInherited !== false
+          });
+          return { success: true, data: reference };
+        } catch (err) {
+          return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+    };
+  }
+});
+
+// src/tools/memory/recall.ts
+var recall_exports = {};
+__export(recall_exports, {
+  tool: () => tool28
+});
+var tool28;
+var init_recall = __esm({
+  "src/tools/memory/recall.ts"() {
+    init_store();
+    tool28 = {
+      name: "recall_memory",
+      description: "Search your memory for previously learned facts about the current project. Use this to recall architecture decisions, patterns, known bugs, or user preferences.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: 'What to search for in memory (e.g., "player data storage", "combat system architecture")'
+          },
+          limit: {
+            type: "number",
+            description: "Max number of facts to return (default: 10)",
+            default: 10
+          }
+        },
+        required: ["query"]
+      },
+      async execute(params) {
+        const query = params.query;
+        const limit = params.limit ?? 10;
+        const projectId = "current";
+        const facts = recallFacts(projectId, query, limit);
+        const summaries = getProjectSummaries(projectId, 5);
+        return {
+          success: true,
+          data: {
+            facts: facts.map((f) => ({ content: f.content, category: f.category })),
+            recentSessions: summaries.map((s) => s.summary)
+          }
+        };
+      }
+    };
+  }
+});
 
-var StudioMsg = {
-  CONNECTED: "studio:connected",
-  DISCONNECTED: "studio:disconnected",
-  EXPLORER: "studio:explorer",
-  OUTPUT: "studio:output",
-  ERROR: "studio:error",
-  SELECTION: "studio:selection",
-  SCRIPT_CONTENT: "studio:script:content",
-  SCRIPT_CHANGED: "studio:script:changed",
-  RESPONSE: "studio:response",
-  REFLECTION: "studio:reflection",
-  TEST_RESULTS: "studio:test:results"
-};
-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"
-};
-function createMessage(type, payload) {
-  return { id: nanoid(), type, payload, ts: Date.now() };
-}
-function parseMessage(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    throw new Error(`Failed to parse WebSocket message: ${raw.slice(0, 100)}`);
+// src/tools/memory/remember.ts
+var remember_exports = {};
+__export(remember_exports, {
+  tool: () => tool29
+});
+var tool29;
+var init_remember = __esm({
+  "src/tools/memory/remember.ts"() {
+    init_store();
+    tool29 = {
+      name: "remember",
+      description: "Store a fact about the current project in persistent memory. Use this to remember architecture decisions, patterns, bugs found, or user preferences so you can recall them in future sessions.",
+      parameters: {
+        type: "object",
+        properties: {
+          fact: {
+            type: "string",
+            description: 'The fact to remember (e.g., "PlayerData DataStore uses key format Player_{UserId}")'
+          },
+          category: {
+            type: "string",
+            description: "Category of the fact",
+            enum: ["architecture", "pattern", "preference", "bug", "api", "general"]
+          }
+        },
+        required: ["fact", "category"]
+      },
+      async execute(params) {
+        const fact = params.fact;
+        const category = params.category ?? "general";
+        const now = Date.now();
+        storeFact({
+          projectId: "current",
+          content: fact,
+          category,
+          source: "agent",
+          relevance: 1,
+          createdAt: now,
+          accessedAt: now
+        });
+        return { success: true, data: { stored: fact, category } };
+      }
+    };
   }
-}
-function serializeMessage(msg) {
-  return JSON.stringify(msg);
-}
+});
+
+// src/tools/cloud/upload-asset.ts
+var upload_asset_exports = {};
+__export(upload_asset_exports, {
+  tool: () => tool30
+});
+var tool30;
+var init_upload_asset = __esm({
+  "src/tools/cloud/upload-asset.ts"() {
+    tool30 = {
+      name: "upload_asset",
+      description: "Upload a local file (image, model, audio) to Roblox via the Open Cloud API. Requires an Open Cloud API key configured in dominus.",
+      parameters: {
+        type: "object",
+        properties: {
+          filePath: {
+            type: "string",
+            description: "Local file path of the asset to upload"
+          },
+          assetType: {
+            type: "string",
+            description: "Type of asset",
+            enum: ["Image", "Audio", "Model"]
+          },
+          name: {
+            type: "string",
+            description: "Display name for the asset on Roblox"
+          },
+          description: {
+            type: "string",
+            description: "Description of the asset"
+          }
+        },
+        required: ["filePath", "assetType", "name"]
+      },
+      async execute(params, ctx) {
+        const apiKey = ctx.config.get("openCloudApiKey");
+        if (!apiKey) {
+          return {
+            success: false,
+            error: "Open Cloud API key not configured. Run: dominus config set openCloudApiKey <key>"
+          };
+        }
+        const filePath = params.filePath;
+        const assetType = params.assetType;
+        const name = params.name;
+        const description = params.description ?? "";
+        if (!fs3.existsSync(filePath)) {
+          return { success: false, error: `File not found: ${filePath}` };
+        }
+        const fileBuffer = fs3.readFileSync(filePath);
+        const fileName = path2.basename(filePath);
+        const typeMapping = {
+          Image: "Decal",
+          Audio: "Audio",
+          Model: "Model"
+        };
+        try {
+          const formData = new FormData();
+          const blob = new Blob([fileBuffer]);
+          formData.append("fileContent", blob, fileName);
+          formData.append(
+            "request",
+            JSON.stringify({
+              assetType: typeMapping[assetType] ?? assetType,
+              displayName: name,
+              description,
+              creationContext: { creator: { userId: "me" } }
+            })
+          );
+          const response = await fetch(
+            "https://apis.roblox.com/assets/v1/assets",
+            {
+              method: "POST",
+              headers: {
+                "x-api-key": apiKey
+              },
+              body: formData
+            }
+          );
+          if (!response.ok) {
+            const text = await response.text();
+            return { success: false, error: `Upload failed (${response.status}): ${text}` };
+          }
+          const data = await response.json();
+          return {
+            success: true,
+            data: {
+              assetId: data.assetId ?? data.id,
+              operationId: data.operationId ?? data.path,
+              name,
+              type: assetType
+            }
+          };
+        } catch (err) {
+          return {
+            success: false,
+            error: `Upload error: ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+      }
+    };
+  }
+});
+
+// src/tools/studio/undo-redo.ts
+var undo_redo_exports = {};
+__export(undo_redo_exports, {
+  redoTool: () => redoTool,
+  undoTool: () => undoTool
+});
+var undoTool, redoTool;
+var init_undo_redo = __esm({
+  "src/tools/studio/undo-redo.ts"() {
+    init_protocol();
+    undoTool = {
+      name: "undo",
+      description: "Undo the last action in Roblox Studio using ChangeHistoryService. Works just like Ctrl+Z. Use this to roll back mistakes.",
+      parameters: {
+        type: "object",
+        properties: {}
+      },
+      async execute(_params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.UNDO, {});
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Undo failed" };
+        }
+        return { success: true, data: "Undo performed" };
+      }
+    };
+    redoTool = {
+      name: "redo",
+      description: "Redo the last undone action in Roblox Studio using ChangeHistoryService. Works just like Ctrl+Y.",
+      parameters: {
+        type: "object",
+        properties: {}
+      },
+      async execute(_params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(CliMsg.REDO, {});
+        const payload = response.payload;
+        if (!payload.success) {
+          return { success: false, error: payload.error ?? "Redo failed" };
+        }
+        return { success: true, data: "Redo performed" };
+      }
+    };
+  }
+});
 
 // src/transport/ws-server.ts
+init_protocol();
 var DominusServer = class extends EventEmitter {
   wss = null;
   /** All connected Studio instances, keyed by placeId (0 for unknown) */
@@ -141,8 +2526,8 @@ var DominusServer = class extends EventEmitter {
     ws.on("close", () => {
       if (this.controllers.has(ws)) {
         this.controllers.delete(ws);
-        for (const [id, controllerWs] of this.relayRequests) {
-          if (controllerWs === ws) this.relayRequests.delete(id);
+        for (const [id, relay] of this.relayRequests) {
+          if (relay.controllerWs === ws) this.relayRequests.delete(id);
         }
       } else {
         const placeId = this.wsToPlaceId.get(ws);
@@ -153,12 +2538,28 @@ var DominusServer = class extends EventEmitter {
           this.emit("studio:disconnected", { placeId, placeName: conn?.placeName });
           this.broadcastToControllers("studio:disconnected", { placeId, placeName: conn?.placeName });
           for (const [id, pending] of this.pendingRequests) {
-            clearTimeout(pending.timer);
-            pending.reject(new Error(`Studio disconnected (place ${placeId})`));
-            this.pendingRequests.delete(id);
+            if (pending.targetWs === ws) {
+              clearTimeout(pending.timer);
+              pending.reject(new Error(`Studio disconnected (place ${placeId})`));
+              this.pendingRequests.delete(id);
+            }
+          }
+          for (const [id, relay] of this.relayRequests) {
+            if (relay.targetWs === ws) {
+              if (relay.controllerWs.readyState === WebSocket.OPEN) {
+                relay.controllerWs.send(serializeMessage({
+                  id,
+                  type: StudioMsg.RESPONSE,
+                  payload: { error: `Studio disconnected (place ${placeId})` },
+                  ts: Date.now()
+                }));
+              }
+              this.relayRequests.delete(id);
+            }
           }
           if (this.activePlaceId === placeId) {
             this.activePlaceId = 0;
+            this.broadcastTargetState();
           }
         }
       }
@@ -177,6 +2578,7 @@ var DominusServer = class extends EventEmitter {
     }
     const conn = {
       ws,
+      connectionId: `${placeId}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`,
       connectedAt: Date.now(),
       studioVersion: payload.studioVersion,
       placeId,
@@ -184,8 +2586,12 @@ var DominusServer = class extends EventEmitter {
     };
     this.studioClients.set(placeId, conn);
     this.wsToPlaceId.set(ws, placeId);
-    this.emit("studio:connected", { ...payload, placeId });
-    this.broadcastToControllers("studio:connected", { ...payload, placeId });
+    if (this.studioClients.size === 1 && this.activePlaceId === 0) {
+      this.activePlaceId = placeId;
+    }
+    this.emit("studio:connected", { ...payload, placeId, connectionId: conn.connectionId });
+    this.broadcastToControllers("studio:connected", { ...payload, placeId, connectionId: conn.connectionId });
+    this.broadcastTargetState();
   }
   addController(ws) {
     this.controllers.add(ws);
@@ -200,6 +2606,27 @@ var DominusServer = class extends EventEmitter {
     }
   }
   handleControllerMessage(controllerWs, msg) {
+    if (msg.type === "controller:set_active_place") {
+      const payload = msg.payload;
+      try {
+        this.setActivePlaceId(Number(payload.placeId ?? 0));
+      } catch (err) {
+        controllerWs.send(serializeMessage({
+          id: msg.id,
+          type: StudioMsg.RESPONSE,
+          payload: { success: false, error: err instanceof Error ? err.message : String(err) },
+          ts: Date.now()
+        }));
+        return;
+      }
+      controllerWs.send(serializeMessage({
+        id: msg.id,
+        type: StudioMsg.RESPONSE,
+        payload: { success: true, activePlaceId: this.activePlaceId, connections: this.listConnections() },
+        ts: Date.now()
+      }));
+      return;
+    }
     const target = this.resolveTarget();
     if (!target || target.ws.readyState !== WebSocket.OPEN) {
       controllerWs.send(serializeMessage({
@@ -210,7 +2637,11 @@ var DominusServer = class extends EventEmitter {
       }));
       return;
     }
-    this.relayRequests.set(msg.id, controllerWs);
+    this.relayRequests.set(msg.id, {
+      controllerWs,
+      targetWs: target.ws,
+      targetPlaceId: target.placeId ?? 0
+    });
     target.ws.send(serializeMessage(msg));
   }
   handleStudioMessage(ws, msg) {
@@ -230,14 +2661,25 @@ var DominusServer = class extends EventEmitter {
       return;
     }
     if (msg.type === StudioMsg.RESPONSE) {
-      const controllerWs = this.relayRequests.get(msg.id);
-      if (controllerWs && controllerWs.readyState === WebSocket.OPEN) {
-        controllerWs.send(serializeMessage(msg));
+      if (!this.wsToPlaceId.has(ws)) return;
+      const relay = this.relayRequests.get(msg.id);
+      if (relay) {
+        if (relay.targetWs !== ws) {
+          this.emit("server:error", new Error(`Ignoring relayed response ${msg.id} from non-target Studio`));
+          return;
+        }
+        if (relay.controllerWs.readyState === WebSocket.OPEN) {
+          relay.controllerWs.send(serializeMessage(msg));
+        }
         this.relayRequests.delete(msg.id);
         return;
       }
       const pending = this.pendingRequests.get(msg.id);
       if (pending) {
+        if (pending.targetWs !== ws) {
+          this.emit("server:error", new Error(`Ignoring response ${msg.id} from non-target Studio`));
+          return;
+        }
         clearTimeout(pending.timer);
         pending.resolve(msg);
         this.pendingRequests.delete(msg.id);
@@ -287,7 +2729,9 @@ var DominusServer = class extends EventEmitter {
       this.pendingRequests.set(msg.id, {
         resolve,
         reject,
-        timer
+        timer,
+        targetWs: target.ws,
+        targetPlaceId: target.placeId ?? 0
       });
       target.ws.send(serializeMessage(msg));
     });
@@ -307,16 +2751,28 @@ var DominusServer = class extends EventEmitter {
   listConnections() {
     return [...this.studioClients.values()].filter((c) => c.ws.readyState === WebSocket.OPEN).map((c) => ({
       placeId: c.placeId ?? 0,
+      connectionId: c.connectionId,
       placeName: c.placeName,
       studioVersion: c.studioVersion,
-      connectedAt: c.connectedAt
+      connectedAt: c.connectedAt,
+      active: this.activePlaceId === 0 && this.studioClients.size === 1 || c.placeId === this.activePlaceId
     }));
   }
   getActivePlaceId() {
     return this.activePlaceId;
   }
   setActivePlaceId(placeId) {
+    if (placeId !== 0 && !this.studioClients.has(placeId)) {
+      throw new Error(`Place ${placeId} is not connected`);
+    }
     this.activePlaceId = placeId;
+    this.broadcastTargetState();
+  }
+  broadcastTargetState() {
+    this.broadcastToControllers("controller:target_state", {
+      activePlaceId: this.activePlaceId,
+      connections: this.listConnections()
+    });
   }
   getPort() {
     return this.port;
@@ -346,6 +2802,9 @@ var DominusServer = class extends EventEmitter {
     });
   }
 };
+
+// src/transport/ws-client.ts
+init_protocol();
 var DominusClient = class extends EventEmitter {
   ws = null;
   port;
@@ -398,12 +2857,7 @@ var DominusClient = class extends EventEmitter {
       if (p.connections) {
         this.connections.clear();
         for (const c of p.connections) {
-          this.connections.set(c.placeId, {
-            connectedAt: c.connectedAt,
-            studioVersion: c.studioVersion,
-            placeId: c.placeId,
-            placeName: c.placeName
-          });
+          this.connections.set(c.placeId, toConnectionInfo(c));
         }
       }
       if (p.activePlaceId !== void 0) {
@@ -414,12 +2868,19 @@ var DominusClient = class extends EventEmitter {
       }
       return;
     }
+    if (msg.type === "controller:target_state") {
+      const payload = msg.payload;
+      this.applyTargetState(payload);
+      this.emit("controller:target_state", payload);
+      return;
+    }
     if (msg.type === "studio:connected") {
       this.studioConnected = true;
       const payload = msg.payload;
       const placeId = payload.placeId ?? 0;
       this.connections.set(placeId, {
         connectedAt: Date.now(),
+        connectionId: payload.connectionId ?? `${placeId}`,
         studioVersion: payload.studioVersion,
         placeId,
         placeName: payload.placeName
@@ -437,6 +2898,7 @@ var DominusClient = class extends EventEmitter {
       if (this.activePlaceId === placeId) {
         this.activePlaceId = 0;
       }
+      this.studioConnected = this.resolveTargetInfo() !== null;
       this.emit("studio:disconnected", payload);
       return;
     }
@@ -481,27 +2943,57 @@ var DominusClient = class extends EventEmitter {
     this.ws.send(serializeMessage(msg));
   }
   isConnected() {
-    return this.studioConnected && this.connections.size > 0;
+    return this.resolveTargetInfo() !== null;
   }
   getConnectionInfo() {
-    if (this.connections.size === 0) return null;
-    const target = this.activePlaceId !== 0 ? this.connections.get(this.activePlaceId) : this.connections.values().next().value;
+    const target = this.resolveTargetInfo();
     if (!target) return null;
     return { ...target, ws: this.ws };
   }
   listConnections() {
     return [...this.connections.values()].map((c) => ({
       placeId: c.placeId ?? 0,
+      connectionId: c.connectionId,
       placeName: c.placeName,
       studioVersion: c.studioVersion,
-      connectedAt: c.connectedAt
+      connectedAt: c.connectedAt,
+      active: this.activePlaceId === 0 && this.connections.size === 1 || c.placeId === this.activePlaceId
     }));
   }
   getActivePlaceId() {
     return this.activePlaceId;
   }
   setActivePlaceId(placeId) {
+    if (placeId !== 0 && !this.connections.has(placeId)) {
+      throw new Error(`Place ${placeId} is not connected`);
+    }
     this.activePlaceId = placeId;
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      const msg = createMessage("controller:set_active_place", { placeId });
+      this.ws.send(serializeMessage(msg));
+    }
+  }
+  applyTargetState(payload) {
+    if (payload.activePlaceId !== void 0) {
+      this.activePlaceId = payload.activePlaceId;
+    }
+    if (payload.connections) {
+      this.connections.clear();
+      for (const c of payload.connections) {
+        this.connections.set(c.placeId, toConnectionInfo(c));
+      }
+    }
+    this.studioConnected = this.resolveTargetInfo() !== null;
+  }
+  resolveTargetInfo() {
+    if (this.connections.size === 0) return null;
+    if (this.activePlaceId !== 0) {
+      return this.connections.get(this.activePlaceId) ?? null;
+    }
+    if (this.connections.size === 1) {
+      return this.connections.values().next().value ?? null;
+    }
+    return null;
   }
   getPort() {
     return this.port;
@@ -521,6 +3013,15 @@ var DominusClient = class extends EventEmitter {
     });
   }
 };
+function toConnectionInfo(c) {
+  return {
+    connectedAt: c.connectedAt,
+    connectionId: c.connectionId,
+    studioVersion: c.studioVersion,
+    placeId: c.placeId,
+    placeName: c.placeName
+  };
+}
 async function isPortInUse(port) {
   return new Promise((resolve) => {
     const ws = new WebSocket(`ws://localhost:${port}`);
@@ -531,200 +3032,20 @@ async function isPortInUse(port) {
     ws.on("open", () => {
       clearTimeout(timer);
       ws.close();
-      resolve(true);
-    });
-    ws.on("error", () => {
-      clearTimeout(timer);
-      resolve(false);
-    });
-  });
-}
-var DOMINUS_DIR = path.join(os.homedir(), ".dominus");
-var CONFIG_PATH = path.join(DOMINUS_DIR, "config.json");
-var DB_PATH = path.join(DOMINUS_DIR, "dominus.db");
-path.join(DOMINUS_DIR, "rules.json");
-var DEFAULTS = {
-  provider: "openai",
-  apiBaseUrl: "",
-  model: "",
-  port: 18088,
-  maxToolIterations: 25,
-  maxVerifyRetries: 3,
-  tokenBudget: 128e3,
-  autoIndex: true,
-  autoLearn: true,
-  userName: "Developer"
-};
-function ensureDir() {
-  if (!fs.existsSync(DOMINUS_DIR)) {
-    fs.mkdirSync(DOMINUS_DIR, { recursive: true });
-  }
-}
-function readJson(filePath, defaults) {
-  try {
-    if (fs.existsSync(filePath)) {
-      const raw = fs.readFileSync(filePath, "utf-8");
-      return { ...defaults, ...JSON.parse(raw) };
-    }
-  } catch {
-  }
-  return { ...defaults };
-}
-function loadConfig() {
-  ensureDir();
-  return readJson(CONFIG_PATH, DEFAULTS);
-}
-function getDbPath() {
-  ensureDir();
-  return DB_PATH;
-}
-
-// src/memory/store.ts
-var db = null;
-var dbPath;
-var SCHEMA = `
-CREATE TABLE IF NOT EXISTS facts (
-  id          INTEGER PRIMARY KEY AUTOINCREMENT,
-  project_id  TEXT NOT NULL,
-  content     TEXT NOT NULL,
-  category    TEXT NOT NULL,
-  source      TEXT,
-  relevance   REAL DEFAULT 1.0,
-  created_at  INTEGER NOT NULL,
-  accessed_at INTEGER NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS summaries (
-  id          INTEGER PRIMARY KEY AUTOINCREMENT,
-  project_id  TEXT NOT NULL,
-  session_id  TEXT NOT NULL,
-  summary     TEXT NOT NULL,
-  created_at  INTEGER NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS messages (
-  id          INTEGER PRIMARY KEY AUTOINCREMENT,
-  session_id  TEXT NOT NULL,
-  role        TEXT NOT NULL,
-  content     TEXT NOT NULL,
-  tool_name   TEXT,
-  created_at  INTEGER NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS script_index (
-  id          INTEGER PRIMARY KEY AUTOINCREMENT,
-  project_id  TEXT NOT NULL,
-  path        TEXT NOT NULL,
-  class_name  TEXT NOT NULL,
-  summary     TEXT,
-  line_count  INTEGER,
-  last_hash   TEXT,
-  updated_at  INTEGER NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_facts_project ON facts(project_id);
-CREATE INDEX IF NOT EXISTS idx_facts_category ON facts(project_id, category);
-CREATE INDEX IF NOT EXISTS idx_scripts_project ON script_index(project_id);
-CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
-CREATE INDEX IF NOT EXISTS idx_summaries_project ON summaries(project_id);
-`;
-function persist() {
-  if (!db) return;
-  const data = db.export();
-  fs.writeFileSync(dbPath, Buffer.from(data));
-}
-async function initMemoryStore() {
-  if (db) return;
-  dbPath = getDbPath();
-  const SQL = await initSqlJs();
-  if (fs.existsSync(dbPath)) {
-    const buffer = fs.readFileSync(dbPath);
-    db = new SQL.Database(buffer);
-  } else {
-    db = new SQL.Database();
-  }
-  db.run(SCHEMA);
-  persist();
-}
-function getDb() {
-  if (!db) throw new Error("Memory store not initialized. Call initMemoryStore() first.");
-  return db;
-}
-function storeFact(fact) {
-  const d = getDb();
-  d.run(
-    `INSERT INTO facts (project_id, content, category, source, relevance, created_at, accessed_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`,
-    [
-      fact.projectId,
-      fact.content,
-      fact.category,
-      fact.source ?? null,
-      fact.relevance,
-      fact.createdAt,
-      fact.accessedAt
-    ]
-  );
-  persist();
-  const stmt = d.prepare("SELECT last_insert_rowid()");
-  stmt.step();
-  const row = stmt.get();
-  stmt.free();
-  return row?.[0] ?? 0;
-}
-function recallFacts(projectId, query, limit = 10) {
-  const d = getDb();
-  const keywords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
-  if (keywords.length === 0) {
-    const result2 = d.exec(
-      `SELECT * FROM facts WHERE project_id = ? ORDER BY relevance DESC, accessed_at DESC LIMIT ?`,
-      [projectId, limit]
-    );
-    return rowsToFacts(result2);
-  }
-  const likeClauses = keywords.map(() => `LOWER(content) LIKE ?`).join(" OR ");
-  const likeParams = keywords.map((k) => `%${k}%`);
-  const result = d.exec(
-    `SELECT * FROM facts WHERE project_id = ? AND (${likeClauses})
-     ORDER BY relevance DESC, accessed_at DESC LIMIT ?`,
-    [projectId, ...likeParams, limit]
-  );
-  const facts = rowsToFacts(result);
-  for (const fact of facts) {
-    if (fact.id) {
-      d.run(`UPDATE facts SET accessed_at = ? WHERE id = ?`, [Date.now(), fact.id]);
-    }
-  }
-  if (facts.length > 0) persist();
-  return facts;
-}
-function rowsToFacts(result) {
-  if (!result[0]) return [];
-  return result[0].values.map((row) => ({
-    id: row[0],
-    projectId: row[1],
-    content: row[2],
-    category: row[3],
-    source: row[4],
-    relevance: row[5],
-    createdAt: row[6],
-    accessedAt: row[7]
-  }));
-}
-function getScriptIndex(projectId) {
-  const d = getDb();
-  const result = d.exec(
-    `SELECT path, summary, class_name FROM script_index WHERE project_id = ? ORDER BY path`,
-    [projectId]
-  );
-  if (!result[0]) return [];
-  return result[0].values.map((row) => ({
-    path: row[0],
-    summary: row[1] || void 0,
-    className: row[2]
-  }));
+      resolve(true);
+    });
+    ws.on("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
 }
 
+// src/mcp/server.ts
+init_protocol();
+init_store();
+init_config();
+
 // src/agent/internal-memory.ts
 var INTERNAL_MEMORY = `## Internal Memory \u2014 Known Quirks & Lessons
 
@@ -786,6 +3107,8 @@ These are built-in lessons that ship with Dominus. Follow them exactly.
 - Converting UI to Roact/React \u2192 use \`convert_ui_to_code\`
 - Creating instances \u2192 use \`create_part\`, \`create_ui\`, \`insert_instance\`, \`build_multiple\`
 - Modifying properties \u2192 use \`set_properties\` or \`bulk_set_properties\`
+- Bulk font/style/scaling changes \u2192 use \`bulk_set_properties\` with filter mode (root + className + properties)
+- Adding UIStroke/UICorner to many instances \u2192 use \`bulk_set_properties\` with \`addChildren\` (idempotent)
 - Reading scripts \u2192 use \`read_script\`
 - Browsing the explorer \u2192 use \`get_explorer\`
 \`run_code\` is ONLY for procedural logic, terrain generation, raycasts, physics queries, or custom algorithms with no tool equivalent.
@@ -795,6 +3118,19 @@ These are built-in lessons that ship with Dominus. Follow them exactly.
 - \`inspect_instance\` \u2014 Returns compact properties + children tree for a single instance in ONE call. Combines get_properties + get_explorer.
 - \`convert_ui_to_code\` \u2014 Serializes a UI tree and generates a Roact/React component. Use when user says "turn this into a component" or "convert to React".
 
+### UI Pre-Flight \u2014 ASK BEFORE BUILDING
+Before creating any non-trivial UI (more than a single element), **ask the user these questions** to avoid rework:
+- **A) Device scaling** \u2014 "Should this UI scale for mobile/tablet, or is it PC-only?"
+  - Mobile: use Scale-based sizing, UIAspectRatioConstraint, TextScaled or AutomaticSize, avoid large pixel offsets.
+  - PC-only: pixel offsets are fine.
+- **B) ScreenGui structure** \u2014 "All panels in one ScreenGui, or separate ScreenGuis per panel?"
+  - One: simpler, easy to toggle all at once.
+  - Separate: independent ZIndex, modular show/hide.
+- **C) Font & style** \u2014 "Any preferred font, color scheme, or style reference?"
+  - Default to Roboto if user has no preference. Use FontFace with Weight=Bold for bold.
+  - Match screenshots closely (transparency, stroke, spacing).
+- Skip these only if the user already specified preferences or the task is trivially small.
+
 ### Verification habits
 - After a build, call \`get_explorer\` or \`get_selection\` to confirm the tree looks right.
 - After editing a script, read it back.
@@ -818,6 +3154,1059 @@ These are built-in lessons that ship with Dominus. Follow them exactly.
 - Use instance Name as dictionary key in children table
 `;
 
+// src/mcp/server.ts
+init_roblox_api();
+
+// src/ai/provider.ts
+init_config();
+var AIProvider = class {
+  client;
+  model;
+  providerName;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key not configured. Run: dominus config set apiKey <your-key>");
+    }
+    const { baseUrl, model } = resolveProviderSettings(config);
+    this.providerName = PROVIDERS[config.provider]?.name ?? config.provider;
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: baseUrl
+    });
+    this.model = model;
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  getModel() {
+    return this.model;
+  }
+  getProviderName() {
+    return this.providerName;
+  }
+  async listModels() {
+    try {
+      const list = await this.client.models.list();
+      const models = [];
+      for await (const m of list) {
+        models.push({ id: m.id, owned_by: m.owned_by });
+      }
+      models.sort((a, b) => a.id.localeCompare(b.id));
+      return models;
+    } catch {
+      return [];
+    }
+  }
+  async chat(messages, tools) {
+    const openAITools = tools?.map(toolToOpenAI);
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      tools: openAITools?.length ? openAITools : void 0,
+      temperature: 0.3
+    });
+    const choice = response.choices[0];
+    if (!choice) throw new Error("No response from AI");
+    const toolCalls = (choice.message.tool_calls ?? []).map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      arguments: JSON.parse(tc.function.arguments)
+    }));
+    return {
+      content: choice.message.content,
+      toolCalls,
+      finishReason: choice.finish_reason ?? "stop",
+      usage: response.usage ? {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      } : void 0
+    };
+  }
+  async *streamChat(messages, tools) {
+    const openAITools = tools?.map(toolToOpenAI);
+    const stream = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      tools: openAITools?.length ? openAITools : void 0,
+      temperature: 0.3,
+      stream: true
+    });
+    const toolCallBuffers = /* @__PURE__ */ new Map();
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta;
+      if (!delta) continue;
+      if (delta.content) {
+        yield { type: "text", content: delta.content };
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          if (!toolCallBuffers.has(tc.index)) {
+            toolCallBuffers.set(tc.index, {
+              id: tc.id ?? "",
+              name: tc.function?.name ?? "",
+              args: ""
+            });
+            if (tc.function?.name) {
+              yield {
+                type: "tool_call_start",
+                toolCall: { id: tc.id, name: tc.function.name }
+              };
+            }
+          }
+          const buffer = toolCallBuffers.get(tc.index);
+          if (tc.id) buffer.id = tc.id;
+          if (tc.function?.name) buffer.name = tc.function.name;
+          if (tc.function?.arguments) {
+            buffer.args += tc.function.arguments;
+            yield {
+              type: "tool_call_delta",
+              content: tc.function.arguments,
+              toolCall: { id: buffer.id, name: buffer.name }
+            };
+          }
+        }
+      }
+      if (chunk.choices[0]?.finish_reason === "tool_calls") {
+        for (const [, buffer] of toolCallBuffers) {
+          let args = {};
+          try {
+            args = JSON.parse(buffer.args);
+          } catch {
+          }
+          yield {
+            type: "tool_call_end",
+            toolCall: { id: buffer.id, name: buffer.name, arguments: args }
+          };
+        }
+        toolCallBuffers.clear();
+      }
+    }
+    yield { type: "done" };
+  }
+};
+function toolToOpenAI(tool31) {
+  return {
+    type: "function",
+    function: {
+      name: tool31.name,
+      description: tool31.description,
+      parameters: tool31.parameters
+    }
+  };
+}
+
+// src/agent/verifier.ts
+init_protocol();
+async function verifyAction(check, ctx) {
+  switch (check.type) {
+    case "script_edit":
+      return verifyScriptEdit(check.path, check.expectedContent, ctx);
+    case "code_run":
+      return verifyCodeRun(ctx);
+    case "instance_create":
+      return verifyInstanceExists(check.path, ctx);
+    case "property_set":
+      return verifyPropertySet(check.path, check.expectedProperties ?? {}, ctx);
+    default:
+      return { success: true };
+  }
+}
+function inferVerifyChecks(call, result) {
+  if (!result.success) return [];
+  switch (call.name) {
+    case "edit_script":
+      return [
+        {
+          type: "script_edit",
+          path: typeof call.arguments.path === "string" ? call.arguments.path : void 0,
+          expectedContent: typeof call.arguments.source === "string" ? call.arguments.source : void 0
+        }
+      ];
+    case "run_code":
+    case "execute_run_test":
+    case "execute_play_test":
+      return [{ type: "code_run" }];
+    case "create_ui":
+    case "create_part":
+    case "clone_instance":
+    case "insert_instance":
+    case "group_instances": {
+      const createdPath = extractPath(result.data) ?? extractStringArg(call.arguments, "path");
+      return createdPath ? [{ type: "instance_create", path: createdPath }] : [];
+    }
+    case "set_properties":
+      return [
+        {
+          type: "property_set",
+          path: extractStringArg(call.arguments, "path"),
+          expectedProperties: asRecord(call.arguments.properties)
+        }
+      ];
+    case "bulk_set_properties": {
+      const path4 = extractPath(result.data) ?? extractStringArg(call.arguments, "path");
+      const properties = asRecord(call.arguments.properties);
+      return path4 && properties ? [{ type: "property_set", path: path4, expectedProperties: properties }] : [];
+    }
+    default:
+      return [];
+  }
+}
+async function verifyScriptEdit(scriptPath, expectedContent, ctx) {
+  if (!ctx.isStudioConnected()) {
+    return { success: false, error: "Studio disconnected during verification" };
+  }
+  try {
+    const response = await ctx.sendToStudio(CliMsg.GET_SCRIPT, {
+      path: scriptPath
+    });
+    if (!response.payload?.source) {
+      return { success: false, error: `Could not read back script: ${scriptPath}` };
+    }
+    if (expectedContent && response.payload.source !== expectedContent) {
+      return {
+        success: false,
+        error: "Script content does not match expected output",
+        data: {
+          expected: expectedContent.slice(0, 200),
+          actual: response.payload.source.slice(0, 200)
+        }
+      };
+    }
+    return { success: true, data: { verified: scriptPath } };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Verification failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function verifyCodeRun(ctx) {
+  if (!ctx.isStudioConnected()) {
+    return { success: false, error: "Studio disconnected during verification" };
+  }
+  try {
+    const response = await ctx.sendToStudio(
+      CliMsg.GET_OUTPUT,
+      { limit: 5, level: "error" }
+    );
+    const errors = response.payload?.entries?.filter((e) => e.level === "error") ?? [];
+    if (errors.length > 0) {
+      return {
+        success: false,
+        error: "Errors detected after code execution",
+        data: { errors: errors.map((e) => e.message) }
+      };
+    }
+    return { success: true };
+  } catch {
+    return { success: true };
+  }
+}
+async function verifyInstanceExists(instancePath, ctx) {
+  if (!ctx.isStudioConnected()) {
+    return { success: false, error: "Studio disconnected during verification" };
+  }
+  try {
+    const response = await ctx.sendToStudio(CliMsg.RUN_CODE, {
+      code: buildInstanceExistsCode(instancePath)
+    });
+    if (response.payload.error) {
+      return { success: false, error: `Instance verification failed: ${response.payload.error}` };
+    }
+    const exists = String(response.payload.output ?? "").trim().toLowerCase();
+    if (!exists.includes("true")) {
+      return { success: false, error: `Instance not found after creation: ${instancePath}` };
+    }
+    return { success: true, data: { exists: instancePath } };
+  } catch {
+    return { success: true };
+  }
+}
+async function verifyPropertySet(instancePath, expectedProperties, ctx) {
+  if (!ctx.isStudioConnected()) {
+    return { success: false, error: "Studio disconnected during verification" };
+  }
+  if (!instancePath || Object.keys(expectedProperties).length === 0) {
+    return { success: true, data: { verified: instancePath } };
+  }
+  try {
+    const response = await ctx.sendToStudio(CliMsg.GET_PROPERTIES, {
+      path: instancePath,
+      compact: false
+    });
+    const entries = response.payload?.properties ?? [];
+    const byName = new Map(entries.map((entry) => [entry.name, entry.value]));
+    const mismatches = [];
+    for (const [name, expected] of Object.entries(expectedProperties)) {
+      const actual = byName.get(name);
+      if (actual == null) {
+        mismatches.push(`${name}: missing`);
+        continue;
+      }
+      if (!matchesPropertyValue(actual, expected)) {
+        mismatches.push(`${name}: expected ${stringifyExpected(expected)}, got ${actual}`);
+      }
+    }
+    if (mismatches.length > 0) {
+      return {
+        success: false,
+        error: "Property verification failed",
+        data: { path: instancePath, mismatches }
+      };
+    }
+    return {
+      success: true,
+      data: { verified: instancePath, properties: Object.keys(expectedProperties) }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Property verification failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function extractPath(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const candidate = data.path;
+  return typeof candidate === "string" ? candidate : void 0;
+}
+function extractStringArg(args, key) {
+  const value = args[key];
+  return typeof value === "string" ? value : void 0;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function buildInstanceExistsCode(instancePath) {
+  const parts = instancePath.split(".").filter(Boolean);
+  const lines = ["local node = game"];
+  for (const part of parts) {
+    lines.push(`node = node and node:FindFirstChild(${luaString(part)})`);
+  }
+  lines.push("return node ~= nil");
+  return lines.join("\n");
+}
+function luaString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function matchesPropertyValue(actual, expected) {
+  const normalizedActual = normalizeValue(actual);
+  if (typeof expected === "boolean" || typeof expected === "number") {
+    return normalizedActual === normalizeValue(String(expected));
+  }
+  if (typeof expected === "string") {
+    const normalizedExpected = normalizeValue(expected);
+    return normalizedActual === normalizedExpected || normalizedActual.includes(normalizedExpected);
+  }
+  if (Array.isArray(expected)) {
+    const normalizedExpected = normalizeValue(expected.join(","));
+    return normalizedActual.includes(normalizedExpected);
+  }
+  if (expected && typeof expected === "object") {
+    const compactExpected = normalizeValue(JSON.stringify(expected));
+    return normalizedActual.includes(compactExpected);
+  }
+  return true;
+}
+function normalizeValue(value) {
+  return value.replace(/[\s{}\[\]"]/g, "").toLowerCase();
+}
+function stringifyExpected(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+
+// src/agent/json-response.ts
+function parseJsonResponse(content) {
+  if (!content) return null;
+  const trimmed = content.trim();
+  const candidates = [
+    trimmed,
+    ...extractMarkdownJsonBlocks(trimmed),
+    ...extractBalancedJsonBlocks(trimmed)
+  ];
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+    }
+  }
+  return null;
+}
+function extractMarkdownJsonBlocks(content) {
+  const matches = content.match(/```(?:json)?\s*([\s\S]*?)```/gi) ?? [];
+  return matches.map((block) => block.replace(/```(?:json)?/i, "").replace(/```$/, "").trim()).filter(Boolean);
+}
+function extractBalancedJsonBlocks(content) {
+  const blocks = [];
+  const openers = ["{", "["];
+  for (let start = 0; start < content.length; start++) {
+    if (!openers.includes(content[start])) continue;
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (let end = start; end < content.length; end++) {
+      const ch = content[end];
+      if (escapeNext) {
+        escapeNext = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escapeNext = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === "{" || ch === "[") depth++;
+      if (ch === "}" || ch === "]") depth--;
+      if (depth === 0) {
+        blocks.push(content.slice(start, end + 1).trim());
+        break;
+      }
+    }
+  }
+  return blocks;
+}
+
+// src/agent/multi-agent/conflicts.ts
+var READ_ONLY_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "get_explorer",
+  "get_properties",
+  "get_descendants_properties",
+  "get_selection",
+  "search_scripts",
+  "read_script",
+  "get_output",
+  "get_class_info",
+  "serialize_ui",
+  "recall_memory",
+  "search_roblox_api",
+  "get_roblox_api_reference"
+]);
+var COORDINATOR_WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "create_ui",
+  "set_properties",
+  "bulk_set_properties",
+  "insert_instance",
+  "move_instance"
+]);
+var FORBIDDEN_WORKER_WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "run_code",
+  "edit_script",
+  "delete_instance",
+  "create_part",
+  "build_multiple",
+  "clone_instance",
+  "group_instances",
+  "find_replace_scripts",
+  "undo",
+  "redo"
+]);
+function normalizeScopePath(pathValue) {
+  return pathValue.trim().replace(/\[(?:"|')([^"']+)(?:"|')\]/g, ".$1").replace(/^game\./i, "").replace(/\.+/g, ".").replace(/^\./, "").replace(/\.$/, "");
+}
+function pathsOverlap(a, b) {
+  const left = normalizeScopePath(a).toLowerCase();
+  const right = normalizeScopePath(b).toLowerCase();
+  if (!left || !right) return false;
+  return left === right || left.startsWith(`${right}.`) || right.startsWith(`${left}.`);
+}
+function isPathWithinScopes(pathValue, scopes) {
+  const target = normalizeScopePath(pathValue).toLowerCase();
+  if (!target) return scopes.length === 0;
+  return scopes.some((scope) => {
+    const normalizedScope = normalizeScopePath(scope).toLowerCase();
+    return target === normalizedScope || target.startsWith(`${normalizedScope}.`);
+  });
+}
+function inferTargetPath(call) {
+  if (call.targetPath) return call.targetPath;
+  const args = call.args ?? {};
+  for (const key of ["path", "root", "rootPath", "parent", "parentPath"]) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  const targets = args.targets;
+  if (Array.isArray(targets)) {
+    const first = targets.find(
+      (target) => target && typeof target === "object" && typeof target.path === "string"
+    );
+    if (first?.path) return first.path;
+  }
+  return void 0;
+}
+function validateWorkerProposal(assignment, proposal) {
+  const errors = [];
+  if (proposal.workerId !== assignment.id) {
+    errors.push(`Proposal workerId "${proposal.workerId}" does not match assignment "${assignment.id}"`);
+  }
+  if (!proposal.summary?.trim()) {
+    errors.push("Proposal summary is required");
+  }
+  for (const call of proposal.proposedToolCalls ?? []) {
+    if (FORBIDDEN_WORKER_WRITE_TOOL_NAMES.has(call.tool)) {
+      errors.push(`Worker proposed forbidden write tool "${call.tool}"`);
+      continue;
+    }
+    if (!COORDINATOR_WRITE_TOOL_NAMES.has(call.tool)) {
+      errors.push(`Worker proposed unsupported coordinator write tool "${call.tool}"`);
+      continue;
+    }
+    const targetPath = inferTargetPath(call);
+    if (!targetPath) {
+      errors.push(`Proposed ${call.tool} call is missing a target path`);
+      continue;
+    }
+    if (!isPathWithinScopes(targetPath, assignment.ownedScopes)) {
+      errors.push(`Proposed ${call.tool} target "${targetPath}" is outside owned scopes`);
+    }
+  }
+  return errors;
+}
+function rejectConflictingAcceptedProposals(accepted) {
+  const finalAccepted = [];
+  const rejected = [];
+  const claimed = [];
+  for (const item of accepted) {
+    const conflict = findConflict(item.proposal, claimed);
+    if (conflict) {
+      rejected.push({
+        workerId: item.workerId,
+        proposal: item.proposal,
+        reason: `Conflicts with accepted worker ${conflict.workerId} on ${conflict.path}`
+      });
+      continue;
+    }
+    finalAccepted.push(item);
+    for (const call of item.proposal.proposedToolCalls) {
+      const targetPath = inferTargetPath(call);
+      if (targetPath) claimed.push({ workerId: item.workerId, path: targetPath });
+    }
+  }
+  return { accepted: finalAccepted, rejected };
+}
+function findConflict(proposal, claimed) {
+  for (const call of proposal.proposedToolCalls) {
+    const targetPath = inferTargetPath(call);
+    if (!targetPath) continue;
+    for (const existing of claimed) {
+      if (pathsOverlap(targetPath, existing.path)) return existing;
+    }
+  }
+  return null;
+}
+
+// src/agent/multi-agent/worker.ts
+var WorkerAgent = class {
+  constructor(ai, tools, toolCtx) {
+    this.ai = ai;
+    this.tools = tools;
+    this.toolCtx = toolCtx;
+  }
+  async run(goal, assignment) {
+    const messages = [
+      {
+        role: "system",
+        content: buildWorkerPrompt(goal, assignment)
+      }
+    ];
+    const toolResults = [];
+    for (let iteration = 0; iteration < 4; iteration++) {
+      const response = await this.ai.chat(messages, this.tools);
+      const assistantMessage = {
+        role: "assistant",
+        content: response.content ?? null,
+        ...response.toolCalls.length > 0 ? {
+          tool_calls: response.toolCalls.map((call) => ({
+            id: call.id,
+            type: "function",
+            function: { name: call.name, arguments: JSON.stringify(call.arguments) }
+          }))
+        } : {}
+      };
+      messages.push(assistantMessage);
+      if (response.toolCalls.length === 0) {
+        const proposal = normalizeProposal(
+          assignment.id,
+          parseJsonResponse(response.content)
+        );
+        if (!proposal) {
+          return {
+            assignment,
+            error: "Worker did not return a valid WorkerProposal JSON object",
+            toolResults
+          };
+        }
+        return { assignment, proposal, toolResults };
+      }
+      for (const call of response.toolCalls) {
+        const tool31 = this.tools.find((candidate) => candidate.name === call.name);
+        const result = tool31 ? await tool31.execute(call.arguments, this.toolCtx) : { success: false, error: `Read-only worker cannot use tool: ${call.name}` };
+        toolResults.push({ call, result });
+        messages.push({
+          role: "tool",
+          content: JSON.stringify(result),
+          tool_call_id: call.id
+        });
+      }
+    }
+    return {
+      assignment,
+      error: "Worker exhausted its iteration budget before returning a proposal",
+      toolResults
+    };
+  }
+};
+function buildWorkerPrompt(goal, assignment) {
+  return [
+    "You are a Dominus worker agent. You are not the coordinator.",
+    "You may inspect and reason, but you must not mutate Roblox Studio.",
+    "Use only the read tools provided to gather evidence.",
+    "Your final answer must be JSON only with this shape:",
+    '{"workerId":"...","summary":"...","evidence":[{"source":"...","summary":"...","data":{}}],"proposedToolCalls":[{"tool":"set_properties","args":{},"targetPath":"...","rationale":"..."}],"risks":["..."],"verificationSuggestions":["..."]}',
+    "",
+    `Global goal: ${goal}`,
+    `Worker id: ${assignment.id}`,
+    `Role: ${assignment.role}`,
+    `Objective: ${assignment.objective}`,
+    `Owned scopes: ${assignment.ownedScopes.join(", ") || "(none)"}`,
+    `Allowed read tools: ${assignment.allowedReadTools.join(", ")}`,
+    "Acceptance criteria:",
+    ...assignment.acceptanceCriteria.map((criterion) => `- ${criterion}`),
+    "",
+    "Proposal rules:",
+    "- Propose only coordinator-owned write tools: create_ui, set_properties, bulk_set_properties, insert_instance, move_instance.",
+    "- Every proposed write must include targetPath and stay inside your owned scopes.",
+    "- If you need no changes, return proposedToolCalls as an empty array and explain why."
+  ].join("\n");
+}
+function normalizeProposal(workerId, parsed) {
+  if (!parsed || typeof parsed !== "object") return null;
+  return {
+    workerId: typeof parsed.workerId === "string" ? parsed.workerId : workerId,
+    summary: typeof parsed.summary === "string" ? parsed.summary : "",
+    evidence: Array.isArray(parsed.evidence) ? parsed.evidence.map((item) => ({
+      source: String(item?.source ?? "worker"),
+      summary: String(item?.summary ?? ""),
+      data: item?.data
+    })) : [],
+    proposedToolCalls: Array.isArray(parsed.proposedToolCalls) ? parsed.proposedToolCalls.map((call) => ({
+      tool: String(call?.tool ?? ""),
+      args: call?.args && typeof call.args === "object" ? call.args : {},
+      targetPath: typeof call?.targetPath === "string" ? call.targetPath : void 0,
+      rationale: typeof call?.rationale === "string" ? call.rationale : void 0
+    })) : [],
+    risks: Array.isArray(parsed.risks) ? parsed.risks.map(String) : [],
+    verificationSuggestions: Array.isArray(parsed.verificationSuggestions) ? parsed.verificationSuggestions.map(String) : []
+  };
+}
+
+// src/agent/multi-agent/coordinator.ts
+var MultiAgentCoordinator = class {
+  constructor(ai, allTools) {
+    this.ai = ai;
+    this.allTools = allTools;
+  }
+  async execute(args, toolCtx, emit) {
+    const normalized = normalizeArgs(args);
+    const readTools = this.getReadOnlyTools();
+    const assignments = await this.createAssignments(normalized, toolCtx, readTools);
+    emit?.({ type: "multi_agent_start", goal: normalized.goal, workerCount: assignments.length });
+    const workerResults = await Promise.allSettled(
+      assignments.map(async (assignment) => {
+        emit?.({
+          type: "multi_agent_worker_start",
+          workerId: assignment.id,
+          role: assignment.role,
+          scopes: assignment.ownedScopes
+        });
+        const worker = new WorkerAgent(this.ai, readTools, toolCtx);
+        const result = await worker.run(normalized.goal, assignment);
+        emit?.({
+          type: "multi_agent_worker_done",
+          workerId: assignment.id,
+          summary: result.proposal?.summary ?? result.error ?? "Worker failed",
+          proposedToolCallCount: result.proposal?.proposedToolCalls.length ?? 0
+        });
+        return result;
+      })
+    );
+    const { accepted, rejected } = this.validateWorkerResults(assignments, workerResults, emit);
+    const conflictChecked = rejectConflictingAcceptedProposals(accepted);
+    for (const item of conflictChecked.rejected) {
+      emit?.({ type: "multi_agent_proposal", workerId: item.workerId, accepted: false, reason: item.reason });
+    }
+    const finalAccepted = conflictChecked.accepted;
+    const finalRejected = [...rejected, ...conflictChecked.rejected];
+    const finalToolCalls = await this.synthesizeFinalToolCalls(normalized.goal, finalAccepted);
+    const decision = {
+      accepted: finalAccepted,
+      rejected: finalRejected,
+      finalToolCalls
+    };
+    emit?.({
+      type: "multi_agent_decision",
+      acceptedCount: decision.accepted.length,
+      rejectedCount: decision.rejected.length,
+      finalToolCallCount: decision.finalToolCalls.length
+    });
+    emit?.({ type: "multi_agent_apply_start", toolCallCount: decision.finalToolCalls.length });
+    const applied = await this.applyFinalToolCalls(decision.finalToolCalls, toolCtx);
+    const verificationFailures = await this.verifyAppliedCalls(applied, toolCtx);
+    emit?.({
+      type: "multi_agent_apply_done",
+      appliedCount: applied.length,
+      verificationFailureCount: verificationFailures.length
+    });
+    return {
+      goal: normalized.goal,
+      assignments,
+      decision,
+      applied,
+      verificationFailures
+    };
+  }
+  getReadOnlyTools() {
+    return this.allTools.filter((tool31) => READ_ONLY_TOOL_NAMES.has(tool31.name));
+  }
+  getMetaTool() {
+    return {
+      name: "run_parallel_task",
+      description: "Split a broad task into coordinated read-only worker agents. Workers inspect and propose scoped changes; the coordinator validates proposals and applies safe serial writes.",
+      parameters: {
+        type: "object",
+        properties: {
+          goal: {
+            type: "string",
+            description: "The task to coordinate across sub-agents."
+          },
+          rootPath: {
+            type: "string",
+            description: "Optional root instance path to partition work under, e.g. StarterGui.HUD."
+          },
+          maxWorkers: {
+            type: "number",
+            description: "Number of workers to use. Defaults to 3, max 5.",
+            default: 3
+          },
+          constraints: {
+            type: "string",
+            description: "Extra constraints the workers and coordinator must follow."
+          },
+          taskType: {
+            type: "string",
+            description: "Optional task type hint such as ui, script, build, refactor, or general."
+          }
+        },
+        required: ["goal"]
+      },
+      execute: async () => ({
+        success: false,
+        error: "run_parallel_task is a meta-tool handled by AgentLoop or MCP, not ToolRegistry."
+      })
+    };
+  }
+  shouldAutoTrigger(userMessage) {
+    const lower = userMessage.toLowerCase();
+    return [
+      "parallel",
+      "sub-agent",
+      "subagent",
+      "agents",
+      "split this",
+      "entire ui",
+      "whole ui",
+      "organize all",
+      "organize entire",
+      "large task"
+    ].some((cue) => lower.includes(cue));
+  }
+  async createAssignments(args, toolCtx, readTools) {
+    const scopes = await this.discoverScopes(args, toolCtx);
+    const fallback = buildFallbackAssignments(args, scopes, readTools);
+    try {
+      const response = await this.ai.chat([
+        {
+          role: "system",
+          content: buildAssignmentPrompt(args, scopes, readTools)
+        }
+      ]);
+      const parsed = parseJsonResponse(response.content);
+      const assignments = normalizeAssignments(parsed?.assignments, args, scopes, readTools);
+      return assignments.length > 0 ? assignments : fallback;
+    } catch {
+      return fallback;
+    }
+  }
+  async discoverScopes(args, toolCtx) {
+    if (!args.rootPath || !toolCtx.isStudioConnected()) {
+      return args.rootPath ? [args.rootPath] : ["Workspace", "StarterGui", "ReplicatedStorage"];
+    }
+    const serializeTool = this.allTools.find((tool31) => tool31.name === "serialize_ui");
+    const looksUi = (args.taskType ?? "").toLowerCase().includes("ui") || args.rootPath.includes("Gui");
+    if (serializeTool && looksUi) {
+      const result = await serializeTool.execute({ path: args.rootPath, maxDepth: 2 }, toolCtx);
+      const childScopes = result.success ? getSerializedChildScopes(args.rootPath, result.data) : [];
+      if (childScopes.length > 0) return childScopes.slice(0, args.maxWorkers);
+    }
+    const explorerTool = this.allTools.find((tool31) => tool31.name === "get_explorer");
+    if (explorerTool) {
+      const result = await explorerTool.execute({ rootPath: args.rootPath, maxDepth: 2 }, toolCtx);
+      const childScopes = result.success ? getExplorerChildScopes(args.rootPath, result.data) : [];
+      if (childScopes.length > 0) return childScopes.slice(0, args.maxWorkers);
+    }
+    return [args.rootPath];
+  }
+  validateWorkerResults(assignments, settledResults, emit) {
+    const accepted = [];
+    const rejected = [];
+    for (let i = 0; i < settledResults.length; i++) {
+      const assignment = assignments[i];
+      const result = settledResults[i];
+      if (result.status === "rejected") {
+        const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+        rejected.push({ workerId: assignment.id, reason });
+        emit?.({ type: "multi_agent_proposal", workerId: assignment.id, accepted: false, reason });
+        continue;
+      }
+      if (!result.value.proposal) {
+        const reason = result.value.error ?? "Worker returned no proposal";
+        rejected.push({ workerId: assignment.id, reason });
+        emit?.({ type: "multi_agent_proposal", workerId: assignment.id, accepted: false, reason });
+        continue;
+      }
+      const errors = validateWorkerProposal(assignment, result.value.proposal);
+      if (errors.length > 0) {
+        const reason = errors.join("; ");
+        rejected.push({ workerId: assignment.id, proposal: result.value.proposal, reason });
+        emit?.({ type: "multi_agent_proposal", workerId: assignment.id, accepted: false, reason });
+        continue;
+      }
+      accepted.push({ workerId: assignment.id, proposal: result.value.proposal });
+      emit?.({ type: "multi_agent_proposal", workerId: assignment.id, accepted: true });
+    }
+    return { accepted, rejected };
+  }
+  async synthesizeFinalToolCalls(goal, accepted) {
+    const proposed = accepted.flatMap((item) => item.proposal.proposedToolCalls);
+    const safeCalls = proposed.filter((call) => COORDINATOR_WRITE_TOOL_NAMES.has(call.tool)).map((call) => toToolCall(call.tool, call.args));
+    if (safeCalls.length <= 1) return safeCalls;
+    try {
+      const response = await this.ai.chat([
+        {
+          role: "system",
+          content: [
+            "You are the Dominus multi-agent coordinator.",
+            "Merge accepted worker proposals into a deterministic serial write plan.",
+            'Return JSON only: {"toolCalls":[{"tool":"set_properties","args":{}}]}',
+            "Only use these tools: create_ui, set_properties, bulk_set_properties, insert_instance, move_instance.",
+            "Do not include run_code, delete_instance, edit_script, undo, or redo.",
+            `Goal: ${goal}`,
+            "Accepted proposals:",
+            JSON.stringify(accepted, null, 2)
+          ].join("\n")
+        }
+      ]);
+      const parsed = parseJsonResponse(
+        response.content
+      );
+      const merged = (parsed?.toolCalls ?? []).filter((call) => call.tool && COORDINATOR_WRITE_TOOL_NAMES.has(call.tool)).map((call) => toToolCall(call.tool, call.args ?? {}));
+      return merged.length > 0 ? merged : safeCalls;
+    } catch {
+      return safeCalls;
+    }
+  }
+  async applyFinalToolCalls(calls, toolCtx) {
+    const applied = [];
+    for (const call of calls) {
+      const targetPath = inferTargetPath({ tool: call.name, args: call.arguments });
+      if (!targetPath) {
+        applied.push({ call, result: { success: false, error: `Missing target path for ${call.name}` } });
+        continue;
+      }
+      const tool31 = this.allTools.find((candidate) => candidate.name === call.name);
+      if (!tool31) {
+        applied.push({ call, result: { success: false, error: `Unknown coordinator tool: ${call.name}` } });
+        continue;
+      }
+      applied.push({ call, result: await tool31.execute(call.arguments, toolCtx) });
+    }
+    return applied;
+  }
+  async verifyAppliedCalls(applied, toolCtx) {
+    const failures = [];
+    for (const { call, result } of applied) {
+      for (const check of inferVerifyChecks(call, result)) {
+        const verified = await verifyAction(check, toolCtx);
+        if (!verified.success) failures.push(verified);
+      }
+    }
+    return failures;
+  }
+};
+function normalizeArgs(args) {
+  return {
+    ...args,
+    goal: String(args.goal ?? "").trim(),
+    maxWorkers: Math.max(1, Math.min(Number(args.maxWorkers ?? 3), 5))
+  };
+}
+function buildAssignmentPrompt(args, scopes, readTools) {
+  return [
+    "You are the Dominus multi-agent assignment planner.",
+    "Create non-overlapping worker assignments for a proposal-only parallel task.",
+    'Return JSON only: {"assignments":[{"id":"worker-1","role":"...","objective":"...","ownedScopes":["..."],"allowedReadTools":["..."],"acceptanceCriteria":["..."]}]}',
+    `Goal: ${args.goal}`,
+    `Root path: ${args.rootPath ?? "(none)"}`,
+    `Task type: ${args.taskType ?? "general"}`,
+    `Constraints: ${args.constraints ?? "(none)"}`,
+    `Max workers: ${args.maxWorkers}`,
+    `Candidate scopes: ${scopes.join(", ")}`,
+    `Read tools: ${readTools.map((tool31) => tool31.name).join(", ")}`
+  ].join("\n");
+}
+function buildFallbackAssignments(args, scopes, readTools) {
+  const selectedScopes = scopes.slice(0, args.maxWorkers);
+  const allowedReadTools = readTools.map((tool31) => tool31.name);
+  const criteria = [
+    "Gather concrete evidence with read-only tools.",
+    "Propose only scoped coordinator-owned write calls.",
+    "Explain risks and verification suggestions."
+  ];
+  return selectedScopes.map((scope, index) => ({
+    id: `worker-${index + 1}`,
+    role: index === 0 ? "Inspector" : index === selectedScopes.length - 1 ? "Verifier" : "Specialist",
+    objective: `Inspect ${scope} for: ${args.goal}`,
+    ownedScopes: [scope],
+    allowedReadTools,
+    acceptanceCriteria: args.constraints ? [...criteria, args.constraints] : criteria
+  }));
+}
+function normalizeAssignments(rawAssignments, args, scopes, readTools) {
+  if (!Array.isArray(rawAssignments)) return [];
+  const allowedReadTools = readTools.map((tool31) => tool31.name);
+  return rawAssignments.slice(0, args.maxWorkers).map((assignment, index) => ({
+    id: assignment.id?.trim() || `worker-${index + 1}`,
+    role: assignment.role?.trim() || "Specialist",
+    objective: assignment.objective?.trim() || `Inspect assigned scope for: ${args.goal}`,
+    ownedScopes: Array.isArray(assignment.ownedScopes) && assignment.ownedScopes.length > 0 ? assignment.ownedScopes.map(String) : [scopes[index] ?? scopes[0] ?? args.rootPath ?? "Workspace"],
+    allowedReadTools: allowedReadTools.filter(
+      (tool31) => assignment.allowedReadTools?.length ? assignment.allowedReadTools.includes(tool31) : true
+    ),
+    acceptanceCriteria: Array.isArray(assignment.acceptanceCriteria) && assignment.acceptanceCriteria.length > 0 ? assignment.acceptanceCriteria.map(String) : ["Gather evidence and propose scoped changes only."]
+  })).filter((assignment) => assignment.ownedScopes.length > 0);
+}
+function getSerializedChildScopes(rootPath, data) {
+  const node = data && typeof data === "object" ? data : null;
+  const children = Array.isArray(node?.Children) ? node.Children : Array.isArray(node?.children) ? node.children : [];
+  return children.map((child) => child && typeof child === "object" ? child.Name : void 0).filter((name) => typeof name === "string" && name.length > 0).map((name) => `${rootPath}.${name}`);
+}
+function getExplorerChildScopes(rootPath, data) {
+  const payload = data && typeof data === "object" ? data : null;
+  const tree = Array.isArray(payload?.tree) ? payload.tree : [];
+  const root = tree[0] && typeof tree[0] === "object" ? tree[0] : null;
+  const children = Array.isArray(root?.children) ? root.children : [];
+  return children.map((child) => child && typeof child === "object" ? child.path : void 0).filter((pathValue) => typeof pathValue === "string" && pathValue.length > 0).map((pathValue) => pathValue || rootPath);
+}
+function toToolCall(name, args) {
+  return {
+    id: `multi_${nanoid()}`,
+    name,
+    arguments: args
+  };
+}
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  readyTasks = [];
+  register(tool31) {
+    if (this.tools.has(tool31.name)) {
+      throw new Error(`Tool already registered: ${tool31.name}`);
+    }
+    this.tools.set(tool31.name, tool31);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  getSchemas() {
+    return this.getAll();
+  }
+  async execute(call, ctx) {
+    const tool31 = this.tools.get(call.name);
+    if (!tool31) {
+      return { success: false, error: `Unknown tool: ${call.name}` };
+    }
+    try {
+      return await tool31.execute(call.arguments, ctx);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, error: message };
+    }
+  }
+  listNames() {
+    return Array.from(this.tools.keys());
+  }
+  addReadyTask(task) {
+    this.readyTasks.push(task);
+  }
+  async ready() {
+    await Promise.all(this.readyTasks);
+  }
+};
+function createDefaultRegistry() {
+  const registry = new ToolRegistry();
+  const toolModules = [
+    Promise.resolve().then(() => (init_read_script(), read_script_exports)),
+    Promise.resolve().then(() => (init_edit_script(), edit_script_exports)),
+    Promise.resolve().then(() => (init_run_code(), run_code_exports)),
+    Promise.resolve().then(() => (init_get_explorer(), get_explorer_exports)),
+    Promise.resolve().then(() => (init_get_properties(), get_properties_exports)),
+    Promise.resolve().then(() => (init_get_descendants_properties(), get_descendants_properties_exports)),
+    Promise.resolve().then(() => (init_set_properties(), set_properties_exports)),
+    Promise.resolve().then(() => (init_insert_instance(), insert_instance_exports)),
+    Promise.resolve().then(() => (init_delete_instance(), delete_instance_exports)),
+    Promise.resolve().then(() => (init_get_output(), get_output_exports)),
+    Promise.resolve().then(() => (init_get_selection(), get_selection_exports)),
+    Promise.resolve().then(() => (init_search_scripts(), search_scripts_exports)),
+    Promise.resolve().then(() => (init_run_tests(), run_tests_exports)),
+    Promise.resolve().then(() => (init_get_class_info(), get_class_info_exports)),
+    Promise.resolve().then(() => (init_create_ui(), create_ui_exports)),
+    Promise.resolve().then(() => (init_execute_run_test(), execute_run_test_exports)),
+    Promise.resolve().then(() => (init_execute_play_test(), execute_play_test_exports)),
+    Promise.resolve().then(() => (init_create_part(), create_part_exports)),
+    Promise.resolve().then(() => (init_clone_instance(), clone_instance_exports)),
+    Promise.resolve().then(() => (init_group_instances(), group_instances_exports)),
+    Promise.resolve().then(() => (init_build_multiple(), build_multiple_exports)),
+    Promise.resolve().then(() => (init_serialize_ui(), serialize_ui_exports)),
+    Promise.resolve().then(() => (init_move_instance(), move_instance_exports)),
+    Promise.resolve().then(() => (init_bulk_set_properties(), bulk_set_properties_exports)),
+    Promise.resolve().then(() => (init_find_replace_scripts(), find_replace_scripts_exports)),
+    Promise.resolve().then(() => (init_search_roblox_api(), search_roblox_api_exports)),
+    Promise.resolve().then(() => (init_get_roblox_api_reference(), get_roblox_api_reference_exports)),
+    Promise.resolve().then(() => (init_recall(), recall_exports)),
+    Promise.resolve().then(() => (init_remember(), remember_exports)),
+    Promise.resolve().then(() => (init_upload_asset(), upload_asset_exports))
+  ];
+  registry.addReadyTask(Promise.all(
+    toolModules.map(async (mod) => {
+      const m = await mod;
+      if (m.tool) registry.register(m.tool);
+    })
+  ));
+  registry.addReadyTask(Promise.resolve().then(() => (init_undo_redo(), undo_redo_exports)).then((m) => {
+    registry.register(m.undoTool);
+    registry.register(m.redoTool);
+  }));
+  return registry;
+}
+
 // src/mcp/server.ts
 var bridge;
 async function startMcpServer() {
@@ -835,7 +4224,7 @@ async function startMcpServer() {
   }
   const mcp = new McpServer({
     name: "dominus",
-    version: "0.6.0"
+    version: "2.0.0"
   }, {
     instructions: INTERNAL_MEMORY
   });
@@ -947,9 +4336,9 @@ ${"	".repeat(_depth)}}`;
     "read_script",
     "Read the source code of a script in Roblox Studio",
     { path: z.string().describe('Full instance path, e.g. "ServerScriptService.GameManager"') },
-    async ({ path: path2 }) => {
+    async ({ path: path4 }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.GET_SCRIPT, { path: path2 });
+      const res = await bridge.sendRequest(CliMsg.GET_SCRIPT, { path: path4 });
       return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
     }
   );
@@ -960,9 +4349,9 @@ ${"	".repeat(_depth)}}`;
       path: z.string().describe("Full instance path"),
       source: z.string().describe("New complete source code")
     },
-    async ({ path: path2, source }) => {
+    async ({ path: path4, source }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.SET_SCRIPT, { path: path2, source });
+      const res = await bridge.sendRequest(CliMsg.SET_SCRIPT, { path: path4, source });
       return { content: [{ type: "text", text: JSON.stringify(res.payload) }] };
     }
   );
@@ -999,9 +4388,9 @@ ${"	".repeat(_depth)}}`;
       path: z.string().describe('Full instance path (e.g. "Workspace.Part", "StarterGui.MyUI.Frame")'),
       compact: z.boolean().optional().default(true).describe("Strip read-only, nil, deprecated, and default-valued properties (default true). Set false for full dump.")
     },
-    async ({ path: path2, compact }) => {
+    async ({ path: path4, compact }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.GET_PROPERTIES, { path: path2, compact });
+      const res = await bridge.sendRequest(CliMsg.GET_PROPERTIES, { path: path4, compact });
       return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
     }
   );
@@ -1013,9 +4402,9 @@ ${"	".repeat(_depth)}}`;
       compact: z.boolean().optional().default(true).describe("Strip noisy/default properties (default true). Set false for full dump."),
       outputFile: z.string().optional().describe("Optional file path to write to prevent limit errors/timeouts")
     },
-    async ({ path: path2, compact, outputFile }) => {
+    async ({ path: path4, compact, outputFile }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.GET_DESCENDANTS_PROPERTIES, { path: path2, compact, outputFile }, 1e3 * 60 * 5);
+      const res = await bridge.sendRequest(CliMsg.GET_DESCENDANTS_PROPERTIES, { path: path4, compact, outputFile }, 1e3 * 60 * 5);
       return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
     }
   );
@@ -1026,9 +4415,9 @@ ${"	".repeat(_depth)}}`;
       path: z.string().describe("Full instance path"),
       properties: z.record(z.unknown()).describe("Key-value pairs of properties to set")
     },
-    async ({ path: path2, properties }) => {
+    async ({ path: path4, properties }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.SET_PROPERTIES, { path: path2, properties });
+      const res = await bridge.sendRequest(CliMsg.SET_PROPERTIES, { path: path4, properties });
       return { content: [{ type: "text", text: JSON.stringify(res.payload) }] };
     }
   );
@@ -1056,9 +4445,9 @@ ${"	".repeat(_depth)}}`;
     "delete_instance",
     "Delete an instance from the Roblox Studio DataModel",
     { path: z.string().describe("Full instance path to delete") },
-    async ({ path: path2 }) => {
+    async ({ path: path4 }) => {
       assertConnected();
-      const res = await bridge.sendRequest(CliMsg.DELETE_INSTANCE, { path: path2 });
+      const res = await bridge.sendRequest(CliMsg.DELETE_INSTANCE, { path: path4 });
       return { content: [{ type: "text", text: JSON.stringify(res.payload) }] };
     }
   );
@@ -1111,6 +4500,61 @@ ${"	".repeat(_depth)}}`;
       return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
     }
   );
+  mcp.tool(
+    "search_roblox_api",
+    "Search Roblox Creator Docs engine API reference names. Use when you are unsure of the exact class, enum, datatype, global, or library name. Works without Studio connected.",
+    {
+      query: z.string().describe('Name fragment to search, e.g. "Text", "Run", "UDim", "FrameStyle"'),
+      kind: z.enum(["any", "class", "datatype", "enum", "global", "library"]).optional().default("any"),
+      limit: z.number().optional().default(10).describe("Maximum results to return")
+    },
+    async ({ query, kind, limit }) => {
+      const results = await searchRobloxApi(query, { kind, limit });
+      return { content: [{ type: "text", text: JSON.stringify({ results }, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "get_roblox_api_reference",
+    "Look up Roblox Creator Docs engine API reference for a class, datatype, enum, global, or library. Includes summaries, descriptions, members, parameters, returns, security, and thread safety. Works without Studio connected.",
+    {
+      name: z.string().describe('API reference name, e.g. "Frame", "RunService", "UDim2", "FrameStyle", "task"'),
+      kind: z.enum(["any", "class", "datatype", "enum", "global", "library"]).optional().default("any"),
+      includeInherited: z.boolean().optional().default(true).describe("For classes, include members from inherited base classes")
+    },
+    async ({ name, kind, includeInherited }) => {
+      const reference = await getRobloxApiReference(name, { kind, includeInherited });
+      return { content: [{ type: "text", text: JSON.stringify(reference, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "run_parallel_task",
+    "Split a broad task into coordinated read-only worker agents. Workers inspect and propose scoped changes; the coordinator validates proposals and applies safe serial writes.",
+    {
+      goal: z.string().describe("The task to coordinate across sub-agents"),
+      rootPath: z.string().optional().describe("Optional root instance path to partition work under, e.g. StarterGui.HUD"),
+      maxWorkers: z.number().optional().default(3).describe("Number of workers to use, max 5"),
+      constraints: z.string().optional().describe("Extra constraints workers and coordinator must follow"),
+      taskType: z.string().optional().describe("Optional task type hint such as ui, script, build, refactor, or general")
+    },
+    async ({ goal, rootPath, maxWorkers, constraints, taskType }) => {
+      const registry = createDefaultRegistry();
+      await registry.ready();
+      const ai = new AIProvider(loadConfig());
+      const coordinator = new MultiAgentCoordinator(ai, registry.getAll());
+      const events = [];
+      const result = await coordinator.execute(
+        { goal, rootPath, maxWorkers, constraints, taskType },
+        createMcpToolContext(),
+        (event) => events.push(event)
+      );
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ ...result, events }, null, 2)
+        }]
+      };
+    }
+  );
   mcp.tool(
     "create_ui",
     'Create an entire UI tree in one call. Pass a declarative JSON tree \u2014 ClassName, Name, properties, Children. All types auto-coerced in Luau (UDim2, Color3, Font, enums). 10x faster than run_code. UDim2: [xScale, xOffset, yScale, yOffset]. Color3: "#hex" or "rgb(r,g,b)". Font: "GothamBold". Enums: string names.',
@@ -1326,11 +4770,11 @@ ${"	".repeat(_depth)}}`;
       path: z.string().describe('Instance path to serialize (e.g. "StarterGui.MyScreenGui")'),
       maxDepth: z.number().optional().default(50).describe("Maximum tree depth (default 50)")
     },
-    async ({ path: path2, maxDepth }) => {
+    async ({ path: path4, maxDepth }) => {
       assertConnected();
       const res = await bridge.sendRequest(
         CliMsg.SERIALIZE_UI,
-        { path: path2, maxDepth },
+        { path: path4, maxDepth },
         1e3 * 60 * 2
       );
       if (!res.payload.success) {
@@ -1375,16 +4819,16 @@ ${"	".repeat(_depth)}}`;
       path: z.string().describe('Full instance path (e.g. "Workspace.MyModel")'),
       childDepth: z.number().optional().default(2).describe("How deep to show the children tree (default 2)")
     },
-    async ({ path: path2, childDepth }) => {
+    async ({ path: path4, childDepth }) => {
       assertConnected();
       const [propRes, treeRes] = await Promise.all([
         bridge.sendRequest(
           CliMsg.GET_PROPERTIES,
-          { path: path2, compact: true }
+          { path: path4, compact: true }
         ),
         bridge.sendRequest(
           CliMsg.GET_EXPLORER,
-          { rootPath: path2, maxDepth: childDepth ?? 2 }
+          { rootPath: path4, maxDepth: childDepth ?? 2 }
         )
       ]);
       return {
@@ -1406,11 +4850,11 @@ ${"	".repeat(_depth)}}`;
       framework: z.enum(["roact", "react"]).optional().default("react").describe('Target framework: "roact" (legacy) or "react" (react-lua, default)'),
       componentName: z.string().optional().describe("Name for the generated component (defaults to instance Name)")
     },
-    async ({ path: path2, framework, componentName }) => {
+    async ({ path: path4, framework, componentName }) => {
       assertConnected();
       const res = await bridge.sendRequest(
         CliMsg.SERIALIZE_UI,
-        { path: path2, maxDepth: 50 },
+        { path: path4, maxDepth: 50 },
         1e3 * 60 * 2
       );
       if (!res.payload.success || !res.payload.tree) {
@@ -1461,7 +4905,16 @@ ${"	".repeat(_depth)}}`;
           }]
         };
       }
-      bridge.setActivePlaceId(placeId);
+      try {
+        bridge.setActivePlaceId(placeId);
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: err instanceof Error ? err.message : String(err)
+          }]
+        };
+      }
       if (placeId === 0) {
         return { content: [{ type: "text", text: "Active place reset to auto-select." }] };
       }
@@ -1527,11 +4980,50 @@ ${"	".repeat(_depth)}}`;
 }
 function assertConnected() {
   if (!bridge.isConnected()) {
+    const connections = bridge.listConnections();
+    const activePlaceId = bridge.getActivePlaceId();
+    if (connections.length > 1 && activePlaceId === 0) {
+      const available = connections.map((c) => `${c.placeName ?? "Unknown"} (${c.placeId})`).join(", ");
+      throw new Error(`Multiple Roblox Studio instances are connected: ${available}. Use list_connections and set_active_place before running Studio tools.`);
+    }
+    if (connections.length > 0 && activePlaceId !== 0) {
+      throw new Error(`Active Roblox Studio place ${activePlaceId} is not connected. Use list_connections and set_active_place to choose a connected Studio instance.`);
+    }
     throw new Error(
       "Roblox Studio is not connected. Open Studio and click the Dominus plugin Connect button."
     );
   }
 }
+function createMcpToolContext() {
+  return {
+    sendToStudio: (type, payload, timeoutMs) => {
+      return bridge.sendRequest(type, payload, timeoutMs);
+    },
+    isStudioConnected: () => bridge.isConnected(),
+    memory: {
+      recall: (query, projectId, limit) => {
+        const facts = recallFacts(projectId || "current", query, limit);
+        return facts.map((fact) => fact.content);
+      },
+      learn: (projectId, facts) => {
+        const now = Date.now();
+        for (const fact of facts) {
+          storeFact({
+            projectId: projectId || "current",
+            content: fact.content,
+            category: fact.category,
+            source: "mcp",
+            relevance: 1,
+            createdAt: now,
+            accessedAt: now
+          });
+        }
+      },
+      getScriptIndex: (projectId) => getScriptIndex(projectId || "current")
+    },
+    config: createConfigAccess()
+  };
+}
 
 // src/mcp/index.ts
 startMcpServer().catch((err) => {