dominus-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,4700 @@
+#!/usr/bin/env node
+import fs4, { existsSync, readFileSync, unlinkSync } from 'fs';
+import path3, { join } from 'path';
+import os2, { tmpdir } from 'os';
+import { nanoid } from 'nanoid';
+import { WebSocket, WebSocketServer } from 'ws';
+import { EventEmitter } from 'events';
+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 { Box, Text, useInput, render } from 'ink';
+import { Command } from 'commander';
+import React6, { useState, useRef, useMemo, useCallback, useEffect } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import TextInput from 'ink-text-input';
+import { execSync } from 'child_process';
+import { randomBytes } from 'crypto';
+import Spinner from 'ink-spinner';
+import OpenAI from 'openai';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+function detectProviderFromEnv() {
+  const priority = ["openai", "anthropic", "gemini", "xai", "openrouter"];
+  for (const p of priority) {
+    const key = process.env[PROVIDERS[p].envVar];
+    if (key) return { provider: p, apiKey: key };
+  }
+  return null;
+}
+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 (!fs4.existsSync(DOMINUS_DIR)) {
+    fs4.mkdirSync(DOMINUS_DIR, { recursive: true });
+  }
+}
+function readJson(filePath, defaults) {
+  try {
+    if (fs4.existsSync(filePath)) {
+      const raw = fs4.readFileSync(filePath, "utf-8");
+      return { ...defaults, ...JSON.parse(raw) };
+    }
+  } catch {
+  }
+  return { ...defaults };
+}
+function writeJson(filePath, data) {
+  ensureDir();
+  fs4.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 getConfigValue(key) {
+  const config = loadConfig();
+  return config[key];
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+}
+function loadRules() {
+  ensureDir();
+  return readJson(RULES_PATH, DEFAULT_RULES);
+}
+function saveRules(rules) {
+  writeJson(RULES_PATH, rules);
+}
+function getDominusDir() {
+  ensureDir();
+  return DOMINUS_DIR;
+}
+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, RULES_PATH, PROVIDERS, DEFAULTS, DEFAULT_RULES;
+var init_config = __esm({
+  "src/config/config.ts"() {
+    DOMINUS_DIR = path3.join(os2.homedir(), ".dominus");
+    CONFIG_PATH = path3.join(DOMINUS_DIR, "config.json");
+    DB_PATH = path3.join(DOMINUS_DIR, "dominus.db");
+    RULES_PATH = path3.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"
+    };
+    DEFAULT_RULES = {
+      do: [],
+      dont: [],
+      conventions: [],
+      context: ""
+    };
+  }
+});
+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",
+      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"
+    };
+  }
+});
+var DominusServer;
+var init_ws_server = __esm({
+  "src/transport/ws-server.ts"() {
+    init_protocol();
+    DominusServer = class extends EventEmitter {
+      wss = null;
+      studioClient = null;
+      controllers = /* @__PURE__ */ new Set();
+      pendingRequests = /* @__PURE__ */ new Map();
+      relayRequests = /* @__PURE__ */ new Map();
+      port;
+      constructor(port = 18088) {
+        super();
+        this.port = port;
+      }
+      start(maxRetries = 0) {
+        return new Promise((resolve, reject) => {
+          const tryPort = (port, attempt) => {
+            const wss = new WebSocketServer({ port });
+            wss.on("listening", () => {
+              this.wss = wss;
+              this.port = port;
+              this.wss.on("connection", (ws) => this.handleConnection(ws));
+              this.emit("server:started", { port });
+              resolve();
+            });
+            wss.on("error", (err) => {
+              if (err.code === "EADDRINUSE" && attempt < maxRetries) {
+                wss.close();
+                tryPort(port + 1, attempt + 1);
+              } else {
+                this.emit("server:error", err);
+                reject(err);
+              }
+            });
+          };
+          tryPort(this.port, 0);
+        });
+      }
+      handleConnection(ws) {
+        let identified = false;
+        ws.on("message", (raw) => {
+          try {
+            const msg = parseMessage(raw.toString());
+            if (!identified) {
+              if (msg.type === StudioMsg.CONNECTED) {
+                identified = true;
+                this.setStudioClient(ws, msg);
+                return;
+              }
+              if (msg.type === "controller:connect") {
+                identified = true;
+                this.addController(ws);
+                ws.send(serializeMessage(createMessage("controller:welcome", {
+                  studioConnected: this.isConnected(),
+                  port: this.port
+                })));
+                return;
+              }
+            }
+            if (this.controllers.has(ws)) {
+              this.handleControllerMessage(ws, msg);
+            } else {
+              this.handleStudioMessage(msg);
+            }
+          } catch (err) {
+            this.emit("server:error", err);
+          }
+        });
+        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);
+            }
+          } else if (this.studioClient?.ws === ws) {
+            this.studioClient = null;
+            this.emit("studio:disconnected");
+            this.broadcastToControllers("studio:disconnected", {});
+            for (const [id, pending] of this.pendingRequests) {
+              clearTimeout(pending.timer);
+              pending.reject(new Error("Studio disconnected"));
+              this.pendingRequests.delete(id);
+            }
+          }
+        });
+        ws.on("error", (err) => {
+          this.emit("server:error", err);
+        });
+      }
+      setStudioClient(ws, msg) {
+        if (this.studioClient) {
+          this.studioClient.ws.close();
+        }
+        const payload = msg.payload;
+        this.studioClient = {
+          ws,
+          connectedAt: Date.now(),
+          studioVersion: payload.studioVersion,
+          placeId: payload.placeId,
+          placeName: payload.placeName
+        };
+        this.emit("studio:connected", payload);
+        this.broadcastToControllers("studio:connected", payload);
+      }
+      addController(ws) {
+        this.controllers.add(ws);
+        this.emit("controller:connected");
+      }
+      broadcastToControllers(type, payload) {
+        const msg = serializeMessage(createMessage(type, payload));
+        for (const ws of this.controllers) {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(msg);
+          }
+        }
+      }
+      handleControllerMessage(controllerWs, msg) {
+        if (!this.studioClient || this.studioClient.ws.readyState !== WebSocket.OPEN) {
+          controllerWs.send(serializeMessage({
+            id: msg.id,
+            type: StudioMsg.RESPONSE,
+            payload: { error: "Studio not connected" },
+            ts: Date.now()
+          }));
+          return;
+        }
+        this.relayRequests.set(msg.id, controllerWs);
+        this.studioClient.ws.send(serializeMessage(msg));
+      }
+      handleStudioMessage(msg) {
+        if (msg.type === StudioMsg.CONNECTED) {
+          const payload = msg.payload;
+          if (this.studioClient) {
+            this.studioClient.studioVersion = payload.studioVersion;
+            this.studioClient.placeId = payload.placeId;
+            this.studioClient.placeName = payload.placeName;
+          }
+          this.emit("studio:connected", payload);
+          this.broadcastToControllers("studio:connected", payload);
+          return;
+        }
+        if (msg.type === StudioMsg.RESPONSE) {
+          const controllerWs = this.relayRequests.get(msg.id);
+          if (controllerWs && controllerWs.readyState === WebSocket.OPEN) {
+            controllerWs.send(serializeMessage(msg));
+            this.relayRequests.delete(msg.id);
+            return;
+          }
+          const pending = this.pendingRequests.get(msg.id);
+          if (pending) {
+            clearTimeout(pending.timer);
+            pending.resolve(msg);
+            this.pendingRequests.delete(msg.id);
+          }
+          return;
+        }
+        this.emit(msg.type, msg.payload);
+        this.emit("message", msg);
+        this.broadcastToControllers(msg.type, msg.payload);
+      }
+      sendRequest(type, payload, timeoutMs = 1e4) {
+        return new Promise((resolve, reject) => {
+          if (!this.studioClient || this.studioClient.ws.readyState !== WebSocket.OPEN) {
+            reject(new Error("No Studio connection"));
+            return;
+          }
+          const msg = createMessage(type, payload);
+          const timer = setTimeout(() => {
+            this.pendingRequests.delete(msg.id);
+            reject(new Error(`Request timed out: ${type}`));
+          }, timeoutMs);
+          this.pendingRequests.set(msg.id, {
+            resolve,
+            reject,
+            timer
+          });
+          this.studioClient.ws.send(serializeMessage(msg));
+        });
+      }
+      sendNotification(type, payload) {
+        if (!this.studioClient || this.studioClient.ws.readyState !== WebSocket.OPEN) {
+          return;
+        }
+        const msg = createMessage(type, payload);
+        this.studioClient.ws.send(serializeMessage(msg));
+      }
+      isConnected() {
+        return this.studioClient !== null && this.studioClient.ws.readyState === WebSocket.OPEN;
+      }
+      getConnectionInfo() {
+        return this.studioClient;
+      }
+      getPort() {
+        return this.port;
+      }
+      stop() {
+        return new Promise((resolve) => {
+          if (this.studioClient) {
+            this.studioClient.ws.close();
+            this.studioClient = null;
+          }
+          for (const ws of this.controllers) {
+            ws.close();
+          }
+          this.controllers.clear();
+          for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Server shutting down"));
+          }
+          this.pendingRequests.clear();
+          this.relayRequests.clear();
+          if (this.wss) {
+            this.wss.close(() => resolve());
+          } else {
+            resolve();
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/memory/store.ts
+var store_exports = {};
+__export(store_exports, {
+  closeMemoryStore: () => closeMemoryStore,
+  decayRelevance: () => decayRelevance,
+  getAllFacts: () => getAllFacts,
+  getDb: () => getDb,
+  getProjectSummaries: () => getProjectSummaries,
+  getScriptEntry: () => getScriptEntry,
+  getScriptIndex: () => getScriptIndex,
+  getSessionMessages: () => getSessionMessages,
+  initMemoryStore: () => initMemoryStore,
+  recallFacts: () => recallFacts,
+  storeFact: () => storeFact,
+  storeMessage: () => storeMessage,
+  storeSummary: () => storeSummary,
+  upsertScript: () => upsertScript
+});
+function persist() {
+  if (!db) return;
+  const data = db.export();
+  fs4.writeFileSync(dbPath, Buffer.from(data));
+}
+async function initMemoryStore() {
+  if (db) return;
+  dbPath = getDbPath();
+  const SQL = await initSqlJs();
+  if (fs4.existsSync(dbPath)) {
+    const buffer = fs4.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 closeMemoryStore() {
+  if (db) {
+    persist();
+    db.close();
+    db = null;
+  }
+}
+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 getAllFacts(projectId) {
+  const d = getDb();
+  const result = d.exec(
+    `SELECT * FROM facts WHERE project_id = ? ORDER BY relevance DESC`,
+    [projectId]
+  );
+  return rowsToFacts(result);
+}
+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 storeMessage(msg) {
+  const d = getDb();
+  d.run(
+    `INSERT INTO messages (session_id, role, content, tool_name, created_at)
+     VALUES (?, ?, ?, ?, ?)`,
+    [msg.sessionId, msg.role, msg.content, msg.toolName ?? null, msg.createdAt]
+  );
+  persist();
+}
+function getSessionMessages(sessionId, limit = 100) {
+  const d = getDb();
+  const result = d.exec(
+    `SELECT * FROM messages WHERE session_id = ? ORDER BY created_at ASC LIMIT ?`,
+    [sessionId, limit]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map((row) => ({
+    id: row[0],
+    sessionId: row[1],
+    role: row[2],
+    content: row[3],
+    toolName: row[4] || void 0,
+    createdAt: row[5]
+  }));
+}
+function storeSummary(summary) {
+  const d = getDb();
+  d.run(
+    `INSERT INTO summaries (project_id, session_id, summary, created_at)
+     VALUES (?, ?, ?, ?)`,
+    [summary.projectId, summary.sessionId, summary.summary, summary.createdAt]
+  );
+  persist();
+}
+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 upsertScript(entry) {
+  const d = getDb();
+  const existing = d.exec(
+    `SELECT id FROM script_index WHERE project_id = ? AND path = ?`,
+    [entry.projectId, entry.path]
+  );
+  if (existing[0]?.values.length) {
+    d.run(
+      `UPDATE script_index SET class_name = ?, summary = ?, line_count = ?, last_hash = ?, updated_at = ?
+       WHERE project_id = ? AND path = ?`,
+      [
+        entry.className,
+        entry.summary ?? null,
+        entry.lineCount ?? null,
+        entry.lastHash ?? null,
+        entry.updatedAt,
+        entry.projectId,
+        entry.path
+      ]
+    );
+  } else {
+    d.run(
+      `INSERT INTO script_index (project_id, path, class_name, summary, line_count, last_hash, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [
+        entry.projectId,
+        entry.path,
+        entry.className,
+        entry.summary ?? null,
+        entry.lineCount ?? null,
+        entry.lastHash ?? null,
+        entry.updatedAt
+      ]
+    );
+  }
+  persist();
+}
+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]
+  }));
+}
+function getScriptEntry(projectId, scriptPath) {
+  const d = getDb();
+  const result = d.exec(
+    `SELECT * FROM script_index WHERE project_id = ? AND path = ?`,
+    [projectId, scriptPath]
+  );
+  if (!result[0]?.values.length) return null;
+  const row = result[0].values[0];
+  return {
+    id: row[0],
+    projectId: row[1],
+    path: row[2],
+    className: row[3],
+    summary: row[4] || void 0,
+    lineCount: row[5] || void 0,
+    lastHash: row[6] || void 0,
+    updatedAt: row[7]
+  };
+}
+function decayRelevance(projectId, factor = 0.95) {
+  const d = getDb();
+  d.run(`UPDATE facts SET relevance = relevance * ? WHERE project_id = ?`, [factor, projectId]);
+  persist();
+}
+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);
+`;
+  }
+});
+
+// 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 an instance in Roblox Studio by its path.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: 'Full instance path (e.g., "Workspace.Part")'
+          }
+        },
+        required: ["path"]
+      },
+      async execute(params, ctx) {
+        if (!ctx.isStudioConnected()) {
+          return { success: false, error: "Studio is not connected" };
+        }
+        const response = await ctx.sendToStudio(
+          CliMsg.GET_PROPERTIES,
+          { path: params.path }
+        );
+        return { success: true, data: response.payload };
+      }
+    };
+  }
+});
+
+// src/tools/studio/set-properties.ts
+var set_properties_exports = {};
+__export(set_properties_exports, {
+  tool: () => tool6
+});
+var tool6;
+var init_set_properties = __esm({
+  "src/tools/studio/set-properties.ts"() {
+    init_protocol();
+    tool6 = {
+      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: () => tool7
+});
+var tool7;
+var init_insert_instance = __esm({
+  "src/tools/studio/insert-instance.ts"() {
+    init_protocol();
+    tool7 = {
+      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: () => tool8
+});
+var tool8;
+var init_delete_instance = __esm({
+  "src/tools/studio/delete-instance.ts"() {
+    init_protocol();
+    tool8 = {
+      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: () => tool9
+});
+var tool9;
+var init_get_output = __esm({
+  "src/tools/studio/get-output.ts"() {
+    init_protocol();
+    tool9 = {
+      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: () => tool10
+});
+var tool10;
+var init_get_selection = __esm({
+  "src/tools/studio/get-selection.ts"() {
+    init_protocol();
+    tool10 = {
+      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: () => tool11
+});
+var tool11;
+var init_search_scripts = __esm({
+  "src/tools/studio/search-scripts.ts"() {
+    init_protocol();
+    tool11 = {
+      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: () => tool12
+});
+var tool12;
+var init_run_tests = __esm({
+  "src/tools/studio/run-tests.ts"() {
+    init_protocol();
+    tool12 = {
+      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: () => tool13
+});
+var tool13;
+var init_get_class_info = __esm({
+  "src/tools/studio/get-class-info.ts"() {
+    init_protocol();
+    tool13 = {
+      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: () => tool14
+});
+var tool14;
+var init_create_ui = __esm({
+  "src/tools/studio/create-ui.ts"() {
+    init_protocol();
+    tool14 = {
+      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), any properties as key-value pairs, and Children (array of child nodes). 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]\n  Font: "GothamBold", "SourceSans", etc. (Enum.Font names)\n  Enums: string name like "Center", "Left", "Fit"\n  FontFace: {Family, Weight, Style}'
+          }
+        },
+        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",
+          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: () => tool15
+});
+var tool15;
+var init_execute_run_test = __esm({
+  "src/tools/studio/execute-run-test.ts"() {
+    init_protocol();
+    tool15 = {
+      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: () => tool16
+});
+var tool16;
+var init_execute_play_test = __esm({
+  "src/tools/studio/execute-play-test.ts"() {
+    init_protocol();
+    tool16 = {
+      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: () => tool17
+});
+var tool17;
+var init_create_part = __esm({
+  "src/tools/studio/create-part.ts"() {
+    init_protocol();
+    tool17 = {
+      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: () => tool18
+});
+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 tool18;
+var init_clone_instance = __esm({
+  "src/tools/studio/clone-instance.ts"() {
+    init_protocol();
+    tool18 = {
+      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: () => tool19
+});
+var tool19;
+var init_group_instances = __esm({
+  "src/tools/studio/group-instances.ts"() {
+    init_protocol();
+    tool19 = {
+      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: () => tool20
+});
+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 tool20;
+var init_build_multiple = __esm({
+  "src/tools/studio/build-multiple.ts"() {
+    init_protocol();
+    tool20 = {
+      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/memory/recall.ts
+var recall_exports = {};
+__export(recall_exports, {
+  tool: () => tool21
+});
+var tool21;
+var init_recall = __esm({
+  "src/tools/memory/recall.ts"() {
+    init_store();
+    tool21 = {
+      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)
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/tools/memory/remember.ts
+var remember_exports = {};
+__export(remember_exports, {
+  tool: () => tool22
+});
+var tool22;
+var init_remember = __esm({
+  "src/tools/memory/remember.ts"() {
+    init_store();
+    tool22 = {
+      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 } };
+      }
+    };
+  }
+});
+
+// src/tools/cloud/upload-asset.ts
+var upload_asset_exports = {};
+__export(upload_asset_exports, {
+  tool: () => tool23
+});
+var tool23;
+var init_upload_asset = __esm({
+  "src/tools/cloud/upload-asset.ts"() {
+    tool23 = {
+      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 (!fs4.existsSync(filePath)) {
+          return { success: false, error: `File not found: ${filePath}` };
+        }
+        const fileBuffer = fs4.readFileSync(filePath);
+        const fileName = path3.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/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startMcpServer: () => startMcpServer
+});
+async function startMcpServer() {
+  const config = loadConfig();
+  await initMemoryStore();
+  wsServer = new DominusServer(config.port);
+  await wsServer.start();
+  const mcp = new McpServer({
+    name: "dominus",
+    version: "0.1.0"
+  });
+  mcp.tool(
+    "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: path4 }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.GET_SCRIPT, { path: path4 });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "edit_script",
+    "Replace the entire source code of a script in Roblox Studio",
+    {
+      path: z.string().describe("Full instance path"),
+      source: z.string().describe("New complete source code")
+    },
+    async ({ path: path4, source }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.SET_SCRIPT, { path: path4, source });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload) }] };
+    }
+  );
+  mcp.tool(
+    "run_code",
+    "Execute Luau code in Roblox Studio and return output",
+    { code: z.string().describe("Luau code to execute") },
+    async ({ code }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.RUN_CODE, { code });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "get_explorer",
+    "Get the DataModel explorer tree from Roblox Studio",
+    {
+      rootPath: z.string().optional().describe("Root path to start from. Omit for entire tree."),
+      maxDepth: z.number().optional().default(3).describe("Maximum tree depth")
+    },
+    async ({ rootPath, maxDepth }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.GET_EXPLORER, {
+        rootPath: rootPath ?? null,
+        maxDepth
+      });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "get_properties",
+    "Get all properties of an instance in Roblox Studio",
+    { path: z.string().describe("Full instance path") },
+    async ({ path: path4 }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.GET_PROPERTIES, { path: path4 });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "set_properties",
+    "Set properties on an instance in Roblox Studio",
+    {
+      path: z.string().describe("Full instance path"),
+      properties: z.record(z.unknown()).describe("Key-value pairs of properties to set")
+    },
+    async ({ path: path4, properties }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.SET_PROPERTIES, { path: path4, properties });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload) }] };
+    }
+  );
+  mcp.tool(
+    "insert_instance",
+    "Create a new instance in the Roblox Studio DataModel",
+    {
+      className: z.string().describe('Class name (e.g. "Part", "Script")'),
+      parentPath: z.string().describe("Parent instance path"),
+      name: z.string().describe("Name for the new instance"),
+      properties: z.record(z.unknown()).optional().describe("Optional properties to set")
+    },
+    async ({ className, parentPath, name, properties }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.INSERT_INSTANCE, {
+        className,
+        parentPath,
+        name,
+        properties: properties ?? {}
+      });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload) }] };
+    }
+  );
+  mcp.tool(
+    "delete_instance",
+    "Delete an instance from the Roblox Studio DataModel",
+    { path: z.string().describe("Full instance path to delete") },
+    async ({ path: path4 }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.DELETE_INSTANCE, { path: path4 });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload) }] };
+    }
+  );
+  mcp.tool(
+    "get_selection",
+    "Get the currently selected instances in Roblox Studio",
+    {},
+    async () => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.GET_SELECTION, {});
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "search_scripts",
+    "Search all scripts in Roblox Studio for a text pattern",
+    {
+      query: z.string().describe("Text to search for"),
+      maxResults: z.number().optional().default(20).describe("Max results")
+    },
+    async ({ query, maxResults }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.SEARCH_SCRIPTS, { query, maxResults });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "get_output",
+    "Get recent output log from Roblox Studio",
+    {
+      limit: z.number().optional().default(50).describe("Max entries"),
+      level: z.enum(["info", "warn", "error"]).optional().describe("Filter by level")
+    },
+    async ({ limit, level }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.GET_OUTPUT, {
+        limit,
+        level: level ?? null
+      });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "get_class_info",
+    "Look up the schema of any Roblox class using ReflectionService. Returns all properties (with types), methods (with parameters), and events. ALWAYS use this before creating or modifying GUI elements to know correct property names and types.",
+    { className: z.string().describe('Roblox class name, e.g. "Frame", "TextLabel", "Part", "MeshPart"') },
+    async ({ className }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.GET_REFLECTION, { className });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, 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.',
+    {
+      parent: z.string().optional().describe('Parent: "StarterGui", "PlayerGui", or path. Default: StarterGui'),
+      tree: z.record(z.unknown()).describe(
+        'Root UI node: {ClassName, Name, properties..., Children: [{...}, ...]}. UDim2 as [xScale, xOffset, yScale, yOffset], Color3 as "#hex", Font as "GothamBold"'
+      )
+    },
+    async ({ parent, tree }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(
+        CliMsg.BUILD_UI,
+        { parent: parent ?? "StarterGui", tree }
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "run_tests",
+    "Run tests by requiring ModuleScripts matching test naming conventions (*.test, *.spec, *Test, *Spec). Lightweight \u2014 does not enter Run/Play mode.",
+    { testName: z.string().optional().describe("Specific test name, or omit to run all") },
+    async ({ testName }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.RUN_TESTS, {
+        testName: testName ?? null
+      });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "execute_run_test",
+    "Start a Run mode test session using StudioTestService:ExecuteRunModeAsync(). This actually enters Run mode in Studio. Pass args that server scripts can retrieve via GetTestArgs(). Yields until EndTest() is called or the session stops. Returns the value from EndTest(). Use for headless automated tests \u2014 no player, just server scripts.",
+    { args: z.unknown().optional().describe("Arguments passed to the test session. Server scripts get this via StudioTestService:GetTestArgs()") },
+    async ({ args }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.EXECUTE_RUN_TEST, { args: args ?? null }, 12e4);
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "execute_play_test",
+    "Start a solo Play mode test session using StudioTestService:ExecutePlayModeAsync(). This enters Play mode with a player character. Pass args that server scripts can retrieve via GetTestArgs(). Yields until EndTest() is called or the session stops. Returns the value from EndTest(). Use for tests needing a player character and full client-server simulation.",
+    { args: z.unknown().optional().describe("Arguments passed to the test session. Server scripts get this via StudioTestService:GetTestArgs()") },
+    async ({ args }) => {
+      assertConnected();
+      const res = await wsServer.sendRequest(CliMsg.EXECUTE_PLAY_TEST, { args: args ?? null }, 12e4);
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "create_part",
+    "Create a Part with position, size, color, material \u2014 all in one call. Faster than insert_instance + set_properties.",
+    {
+      name: z.string().describe("Name for the part"),
+      parent: z.string().optional().describe("Parent path (default: Workspace)"),
+      shape: z.enum(["Block", "Ball", "Cylinder", "Wedge", "CornerWedge"]).optional().describe("Part shape"),
+      position: z.object({ x: z.number(), y: z.number(), z: z.number() }).optional().describe("World position"),
+      size: z.object({ x: z.number(), y: z.number(), z: z.number() }).optional().describe("Size in studs"),
+      color: z.string().optional().describe('Hex "#00FF00", BrickColor name, or "rgb(0,255,0)"'),
+      material: z.string().optional().describe("Plastic, Wood, Grass, Neon, Metal, etc."),
+      transparency: z.number().optional().describe("0=opaque, 1=invisible"),
+      anchored: z.boolean().optional().describe("Anchored (default: true)"),
+      canCollide: z.boolean().optional().describe("Has collision")
+    },
+    async (params) => {
+      assertConnected();
+      const properties = {};
+      if (params.position) properties.Position = { X: params.position.x, Y: params.position.y, Z: params.position.z };
+      if (params.size) properties.Size = { X: params.size.x, Y: params.size.y, Z: params.size.z };
+      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 wsServer.sendRequest(CliMsg.INSERT_INSTANCE, {
+        className,
+        parentPath: params.parent ?? "Workspace",
+        name: params.name,
+        properties
+      });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "clone_instance",
+    "Clone an existing instance, optionally rename it, move it, or offset its position",
+    {
+      path: z.string().describe("Path of instance to clone"),
+      newName: z.string().optional().describe("Name for the clone"),
+      newParent: z.string().optional().describe("Parent path for the clone"),
+      offset: z.object({ x: z.number(), y: z.number(), z: z.number() }).optional().describe("Position offset from original")
+    },
+    async (params) => {
+      assertConnected();
+      const parts = params.path.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 pp = params.newParent.split(".");
+        let pr = "game";
+        for (const p of pp) pr += `["${p}"]`;
+        lines.push(`clone.Parent = ${pr}`);
+      } else {
+        lines.push(`clone.Parent = orig.Parent`);
+      }
+      if (params.offset) {
+        lines.push(`if clone:IsA("BasePart") then`);
+        lines.push(`  clone.Position = clone.Position + Vector3.new(${params.offset.x}, ${params.offset.y}, ${params.offset.z})`);
+        lines.push(`end`);
+      }
+      lines.push(`print("Cloned: " .. clone:GetFullName())`);
+      const res = await wsServer.sendRequest(CliMsg.RUN_CODE, { code: lines.join("\n") });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "group_instances",
+    "Group multiple instances into a Model or Folder",
+    {
+      paths: z.array(z.string()).describe("Array of instance paths to group"),
+      groupName: z.string().describe("Name for the group"),
+      groupClass: z.enum(["Model", "Folder"]).optional().describe("Container class (default: Model)"),
+      parent: z.string().optional().describe("Parent path (default: Workspace)")
+    },
+    async (params) => {
+      assertConnected();
+      const gc = params.groupClass ?? "Model";
+      const parent = params.parent ?? "Workspace";
+      const parentParts = parent.split(".");
+      let parentResolve = "game";
+      for (const p of parentParts) parentResolve += `["${p}"]`;
+      const resolves = params.paths.map((path4) => {
+        const parts = path4.split(".");
+        let r = "game";
+        for (const part of parts) r += `["${part}"]`;
+        return r;
+      });
+      const code = [
+        `local group = Instance.new("${gc}")`,
+        `group.Name = "${params.groupName}"`,
+        `group.Parent = ${parentResolve}`,
+        ...resolves.map((r) => `${r}.Parent = group`),
+        `print("Grouped ${params.paths.length} instances into: " .. group:GetFullName())`
+      ].join("\n");
+      const res = await wsServer.sendRequest(CliMsg.RUN_CODE, { code });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "build_multiple",
+    "Create many parts/instances in one batch. Send an array of specs \u2014 all created in a single round-trip. Ideal for building trees, houses, vehicles.",
+    {
+      parts: z.array(z.object({
+        name: z.string(),
+        className: z.string().optional(),
+        parent: z.string().optional(),
+        position: z.object({ x: z.number(), y: z.number(), z: z.number() }).optional(),
+        size: z.object({ x: z.number(), y: z.number(), z: z.number() }).optional(),
+        color: z.string().optional().describe('Hex "#RRGGBB" or BrickColor name'),
+        material: z.string().optional(),
+        transparency: z.number().optional(),
+        anchored: z.boolean().optional(),
+        shape: z.enum(["Block", "Ball", "Cylinder", "Wedge"]).optional()
+      })).describe("Array of part specifications"),
+      groupName: z.string().optional().describe("Group all parts into a Model with this name"),
+      groupParent: z.string().optional().describe("Parent for the group (default: Workspace)")
+    },
+    async (params) => {
+      assertConnected();
+      const parts = params.parts;
+      const groupName = params.groupName;
+      const groupParent = params.groupParent ?? "Workspace";
+      function resolveP(path4) {
+        const segs = path4.split(".");
+        let r = "game";
+        for (const s of segs) r += `["${s}"]`;
+        return r;
+      }
+      const lines = [];
+      if (groupName) {
+        lines.push(`local _group = Instance.new("Model")`);
+        lines.push(`_group.Name = "${groupName}"`);
+        lines.push(`_group.Parent = ${resolveP(groupParent)}`);
+      }
+      for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        const v = `_p${i}`;
+        const cn = p.className ?? (p.shape === "Wedge" ? "WedgePart" : "Part");
+        lines.push(`local ${v} = Instance.new("${cn}")`);
+        lines.push(`${v}.Name = "${p.name}"`);
+        if (p.position) lines.push(`${v}.Position = Vector3.new(${p.position.x}, ${p.position.y}, ${p.position.z})`);
+        if (p.size) lines.push(`${v}.Size = Vector3.new(${p.size.x}, ${p.size.y}, ${p.size.z})`);
+        if (p.color) {
+          if (p.color.startsWith("#")) lines.push(`${v}.Color = Color3.fromHex("${p.color}")`);
+          else lines.push(`${v}.BrickColor = BrickColor.new("${p.color}")`);
+        }
+        if (p.material) lines.push(`${v}.Material = Enum.Material.${p.material}`);
+        if (p.transparency !== void 0) lines.push(`${v}.Transparency = ${p.transparency}`);
+        lines.push(`${v}.Anchored = ${p.anchored ?? true}`);
+        if (p.shape && p.shape !== "Block" && cn === "Part") lines.push(`${v}.Shape = Enum.PartType.${p.shape}`);
+        lines.push(`${v}.Parent = ${groupName ? "_group" : resolveP(p.parent ?? "Workspace")}`);
+      }
+      lines.push(`print("Built ${parts.length} parts${groupName ? ` in ${groupName}` : ""}")`);
+      const res = await wsServer.sendRequest(CliMsg.RUN_CODE, { code: lines.join("\n") });
+      return { content: [{ type: "text", text: JSON.stringify(res.payload, null, 2) }] };
+    }
+  );
+  mcp.tool(
+    "recall_memory",
+    "Search persistent memory for facts about the current Roblox project",
+    { query: z.string().describe("What to search for") },
+    async ({ query }) => {
+      const facts = recallFacts("current", query, 15);
+      const scripts = getScriptIndex("current");
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ facts: facts.map((f) => f.content), scriptIndex: scripts }, null, 2)
+        }]
+      };
+    }
+  );
+  mcp.tool(
+    "remember",
+    "Store a fact about the project in persistent memory for future sessions",
+    {
+      fact: z.string().describe("The fact to remember"),
+      category: z.enum(["architecture", "pattern", "preference", "bug", "api", "general"]).describe("Category")
+    },
+    async ({ fact, category }) => {
+      const now = Date.now();
+      storeFact({ projectId: "current", content: fact, category, source: "mcp", relevance: 1, createdAt: now, accessedAt: now });
+      return { content: [{ type: "text", text: `Remembered: ${fact}` }] };
+    }
+  );
+  mcp.resource(
+    "studio://status",
+    "studio://status",
+    async () => {
+      const info = wsServer.getConnectionInfo();
+      return {
+        contents: [{
+          uri: "studio://status",
+          text: JSON.stringify({
+            connected: wsServer.isConnected(),
+            placeName: info?.placeName,
+            placeId: info?.placeId,
+            studioVersion: info?.studioVersion,
+            port: wsServer.getPort()
+          }, null, 2),
+          mimeType: "application/json"
+        }]
+      };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await mcp.connect(transport);
+}
+function assertConnected() {
+  if (!wsServer.isConnected()) {
+    throw new Error(
+      "Roblox Studio is not connected. Open Studio and click the Dominus plugin Connect button."
+    );
+  }
+}
+var wsServer;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    init_ws_server();
+    init_protocol();
+    init_store();
+    init_config();
+  }
+});
+var CROWN_ART = `    \u25C6       \u25C6       \u25C6
+   \u2554\u2588\u2557     \u2554\u2588\u2557     \u2554\u2588\u2557
+   \u2551\u2588\u2551     \u2551\u2588\u2551     \u2551\u2588\u2551
+   \u255A\u2588\u255A\u2550\u2550\u2550\u2550\u2550\u255D\u2588\u255A\u2550\u2550\u2550\u2550\u2550\u255D\u2588\u255D
+    \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`;
+function getGreeting(name) {
+  const hour = (/* @__PURE__ */ new Date()).getHours();
+  if (hour >= 5 && hour < 12) return `Good morning ${name}!`;
+  if (hour >= 12 && hour < 17) return `Good afternoon ${name}!`;
+  if (hour >= 17 && hour < 21) return `Good evening ${name}!`;
+  return `Burning the midnight oil, ${name}!`;
+}
+var Welcome = React6.memo(({
+  userName,
+  version,
+  model,
+  provider,
+  port,
+  hasApiKey,
+  connected,
+  cwd
+}) => {
+  const greeting = getGreeting(userName);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: "100%", children: [
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        borderStyle: "round",
+        borderColor: "magenta",
+        paddingX: 1,
+        justifyContent: "space-between",
+        children: [
+          /* @__PURE__ */ jsxs(Text, { bold: true, color: "magenta", children: [
+            "Dominus v",
+            version
+          ] }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "AI-Powered Roblox Studio Agent" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(
+        Box,
+        {
+          flexDirection: "column",
+          borderStyle: "round",
+          borderColor: "gray",
+          paddingX: 2,
+          paddingY: 1,
+          width: "50%",
+          children: [
+            /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: greeting }),
+            /* @__PURE__ */ jsx(Text, { children: " " }),
+            CROWN_ART.split("\n").map((line, i) => /* @__PURE__ */ jsx(Text, { color: "yellow", children: line }, i)),
+            /* @__PURE__ */ jsx(Text, { children: " " }),
+            /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+              provider,
+              " \xB7 ",
+              model || "no model set"
+            ] }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: cwd })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Box,
+        {
+          flexDirection: "column",
+          borderStyle: "round",
+          borderColor: "gray",
+          paddingX: 2,
+          paddingY: 1,
+          width: "50%",
+          children: hasApiKey ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { bold: true, color: "yellow", children: "Tips for getting started" }),
+            /* @__PURE__ */ jsx(Text, { children: "Just type a message to chat with the AI agent" }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              "Use ",
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: "/help" }),
+              " to see all commands"
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              "Use ",
+              /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+                "/run ",
+                "<code>"
+              ] }),
+              " to execute Luau in Studio"
+            ] }),
+            /* @__PURE__ */ jsx(Text, { children: " " }),
+            /* @__PURE__ */ jsx(Text, { bold: true, color: "yellow", children: "Studio connection" }),
+            connected ? /* @__PURE__ */ jsx(Text, { color: "green", children: "\u25CF Connected to Roblox Studio" }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "red", children: "\u25CB Waiting for Studio plugin..." }),
+              /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                "WebSocket server on port ",
+                port
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                "Run ",
+                /* @__PURE__ */ jsx(Text, { color: "cyan", children: "dominus install-plugin" }),
+                " if needed"
+              ] })
+            ] })
+          ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { bold: true, color: "yellow", children: "Setup \u2014 pick any provider" }),
+            /* @__PURE__ */ jsx(Text, { children: " " }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "green", bold: true, children: "OpenAI     " }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "set " }),
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: "OPENAI_API_KEY" })
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "green", bold: true, children: "Anthropic  " }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "set " }),
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: "ANTHROPIC_API_KEY" })
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "green", bold: true, children: "Gemini     " }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "set " }),
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: "GEMINI_API_KEY" })
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "green", bold: true, children: "Grok (xAI) " }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "set " }),
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: "XAI_API_KEY" })
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "green", bold: true, children: "OpenRouter " }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "set " }),
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: "OPENROUTER_API_KEY" })
+            ] }),
+            /* @__PURE__ */ jsx(Text, { children: " " }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Or configure manually:" }),
+            /* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsx(Text, { color: "cyan", children: "dominus config set provider openai" }) }),
+            /* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsx(Text, { color: "cyan", children: "dominus config set apiKey sk-..." }) })
+          ] })
+        }
+      )
+    ] })
+  ] });
+});
+
+// src/ui/components/Setup.tsx
+init_config();
+var PROVIDER_OPTIONS = [
+  { key: "openai", label: "OpenAI", hint: "GPT-5.3, GPT-5.2, o3-mini" },
+  { key: "anthropic", label: "Anthropic", hint: "Claude Opus 4-6, Sonnet 4-6" },
+  { key: "gemini", label: "Google Gemini", hint: "Gemini 3.1 Pro, 2.0 Flash" },
+  { key: "xai", label: "xAI (Grok)", hint: "Grok 4.2, Grok 3" },
+  { key: "openrouter", label: "OpenRouter", hint: "300+ models, one key" }
+];
+var Setup = ({ onComplete }) => {
+  const [step, setStep] = useState("provider");
+  const [selectedIdx, setSelectedIdx] = useState(0);
+  const [selectedProvider, setSelectedProvider] = useState("openai");
+  const [apiKey, setApiKey] = useState("");
+  useInput((input, key) => {
+    if (step !== "provider") return;
+    if (key.upArrow) {
+      setSelectedIdx((prev) => Math.max(0, prev - 1));
+    } else if (key.downArrow) {
+      setSelectedIdx((prev) => Math.min(PROVIDER_OPTIONS.length - 1, prev + 1));
+    } else if (key.return) {
+      setSelectedProvider(PROVIDER_OPTIONS[selectedIdx].key);
+      setStep("key");
+    }
+  });
+  const handleKeySubmit = (value) => {
+    const trimmed = value.trim();
+    if (trimmed) {
+      onComplete(selectedProvider, trimmed);
+    }
+  };
+  const providerInfo = PROVIDERS[selectedProvider];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "magenta", children: "\u25C6 Dominus \u2014 First Time Setup" }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    step === "provider" && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Select your AI provider:" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      PROVIDER_OPTIONS.map((opt, i) => /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { color: i === selectedIdx ? "cyan" : void 0, bold: i === selectedIdx, children: [
+          i === selectedIdx ? " \u276F " : "   ",
+          opt.label
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "  ",
+          opt.hint
+        ] })
+      ] }, opt.key)),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191/\u2193 to select, Enter to confirm" })
+    ] }),
+    step === "key" && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "Provider: ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: PROVIDERS[selectedProvider].name })
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "Default model: ",
+        /* @__PURE__ */ jsx(Text, { color: "green", children: providerInfo.defaultModel })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Enter your API key:" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Get one from your provider's dashboard" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u276F " }),
+        /* @__PURE__ */ jsx(
+          TextInput,
+          {
+            value: apiKey,
+            onChange: setApiKey,
+            onSubmit: handleKeySubmit,
+            mask: "*",
+            placeholder: "sk-..."
+          }
+        )
+      ] })
+    ] })
+  ] });
+};
+var StatusBar = React6.memo(({
+  connected,
+  placeName,
+  model,
+  sessionTokens
+}) => {
+  const statusColor = connected ? "green" : "red";
+  const statusText = connected ? `\u25CF Connected${placeName ? ` \u2014 ${placeName}` : ""}` : "\u25CB Disconnected";
+  const shortModel = model.split("/").pop() ?? model;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "single",
+      borderColor: "gray",
+      paddingX: 1,
+      justifyContent: "space-between",
+      width: "100%",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { gap: 2, children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, color: "magenta", children: "DOMINUS" }),
+          /* @__PURE__ */ jsx(Text, { color: statusColor, children: statusText })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { gap: 2, children: [
+          sessionTokens !== void 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "~",
+            Math.round(sessionTokens / 1e3),
+            "k tokens"
+          ] }),
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: shortModel }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Ctrl+C to quit" })
+        ] })
+      ]
+    }
+  );
+});
+function formatTime(ts) {
+  const d = new Date(ts);
+  return d.toLocaleTimeString("en-US", { hour12: false });
+}
+var LEVEL_COLORS = {
+  info: "white",
+  warn: "yellow",
+  error: "red"
+};
+var LEVEL_ICONS = {
+  info: "\u2502",
+  warn: "\u26A0",
+  error: "\u2716"
+};
+var OutputPane = React6.memo(({ entries, maxLines = 10 }) => {
+  const visible = entries.slice(-maxLines);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, dimColor: true, children: "Output" }),
+    visible.length === 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, italic: true, children: "Waiting for Studio output..." }) : visible.map((entry, i) => /* @__PURE__ */ jsxs(Text, { color: LEVEL_COLORS[entry.level] ?? "white", children: [
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "[",
+        formatTime(entry.timestamp),
+        "]"
+      ] }),
+      " ",
+      /* @__PURE__ */ jsx(Text, { children: LEVEL_ICONS[entry.level] ?? "\u2502" }),
+      " ",
+      entry.message
+    ] }, i))
+  ] });
+});
+function formatTime2(ts) {
+  const d = new Date(ts);
+  return d.toLocaleTimeString("en-US", { hour12: false });
+}
+var ChatPane = React6.memo(({ entries, streaming, maxLines = 20 }) => {
+  const visible = entries.slice(-maxLines);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingX: 1, children: [
+    visible.map((entry, i) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: entry.role === "user" ? 1 : 0, children: [
+      entry.role === "user" && /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { color: "cyan", bold: true, children: [
+          "You",
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "[",
+          formatTime2(entry.timestamp),
+          "]"
+        ] })
+      ] }),
+      entry.role === "assistant" && /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { color: "magenta", bold: true, children: [
+          "Dominus",
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "[",
+          formatTime2(entry.timestamp),
+          "]"
+        ] })
+      ] }),
+      entry.role === "tool" && /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+        "\u26A1 ",
+        entry.toolName ?? "tool",
+        ": ",
+        entry.content
+      ] }),
+      entry.role === "system" && /* @__PURE__ */ jsx(Text, { color: "yellow", bold: true, children: "Dominus " }),
+      entry.role === "error" && /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+        "\u2716 Error: ",
+        entry.content
+      ] }),
+      (entry.role === "user" || entry.role === "assistant" || entry.role === "system") && /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: entry.content })
+    ] }, i)),
+    streaming && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { color: "magenta", bold: true, children: [
+          "Dominus",
+          " "
+        ] }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "(typing...)" })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: streaming })
+    ] })
+  ] });
+});
+function getClipboardImage() {
+  if (process.platform !== "win32") {
+    return getClipboardImageUnix();
+  }
+  const tmpPath = join(tmpdir(), `dominus-clip-${randomBytes(4).toString("hex")}.png`);
+  try {
+    execSync(
+      `powershell -NoProfile -Command "Add-Type -AssemblyName System.Windows.Forms; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img -eq $null) { exit 1 }; $img.Save('${tmpPath.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png); $img.Dispose()"`,
+      { stdio: "pipe", timeout: 5e3 }
+    );
+    if (!existsSync(tmpPath)) return null;
+    const buffer = readFileSync(tmpPath);
+    unlinkSync(tmpPath);
+    if (buffer.length < 100) return null;
+    return {
+      base64: buffer.toString("base64"),
+      mimeType: "image/png"
+    };
+  } catch {
+    try {
+      if (existsSync(tmpPath)) unlinkSync(tmpPath);
+    } catch {
+    }
+    return null;
+  }
+}
+function getClipboardImageUnix() {
+  const tmpPath = join(tmpdir(), `dominus-clip-${randomBytes(4).toString("hex")}.png`);
+  try {
+    if (process.platform === "darwin") {
+      execSync(`osascript -e 'set png to (the clipboard as \xABclass PNGf\xBB)' -e 'set f to open for access POSIX file "${tmpPath}" with write permission' -e 'write png to f' -e 'close access f'`, { stdio: "pipe", timeout: 5e3 });
+    } else {
+      execSync(`xclip -selection clipboard -t image/png -o > "${tmpPath}"`, { stdio: "pipe", timeout: 5e3 });
+    }
+    if (!existsSync(tmpPath)) return null;
+    const buffer = readFileSync(tmpPath);
+    unlinkSync(tmpPath);
+    if (buffer.length < 100) return null;
+    return {
+      base64: buffer.toString("base64"),
+      mimeType: "image/png"
+    };
+  } catch {
+    try {
+      if (existsSync(tmpPath)) unlinkSync(tmpPath);
+    } catch {
+    }
+    return null;
+  }
+}
+var COMMANDS = [
+  { command: "/help", description: "Show help and available commands" },
+  { command: "/model", description: "Switch the AI model" },
+  { command: "/models", description: "List all available models from your provider" },
+  { command: "/status", description: "Show connection and config status" },
+  { command: "/clear", description: "Clear chat history" },
+  { command: "/paste", description: "Paste image from clipboard (or Alt+V)" }
+];
+var SuggestionBox = React6.memo(
+  ({ suggestions, selectedIdx }) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, borderStyle: "single", borderColor: "gray", children: [
+    suggestions.map((s, i) => /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: i === selectedIdx ? "cyan" : void 0, bold: i === selectedIdx, children: i === selectedIdx ? "\u276F " : "  " }),
+      /* @__PURE__ */ jsx(Text, { color: i === selectedIdx ? "cyan" : "white", bold: i === selectedIdx, children: s.command.padEnd(16) }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: s.description })
+    ] }, s.command)),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  \u2191\u2193 navigate \xB7 Tab complete \xB7 Enter select" })
+  ] })
+);
+var InputBar = React6.memo(({
+  onSubmit,
+  onImagePaste,
+  isProcessing,
+  placeholder = "Ask Dominus anything, or /help for commands...",
+  imageAttached,
+  onClearImage
+}) => {
+  const [value, setValue] = useState("");
+  const [selectedIdx, setSelectedIdx] = useState(0);
+  const [pasteStatus, setPasteStatus] = useState("none");
+  const valueRef = useRef(value);
+  valueRef.current = value;
+  const suggestions = useMemo(() => {
+    if (!value.startsWith("/") || value.includes(" ")) return [];
+    const query = value.toLowerCase();
+    return COMMANDS.filter((c) => c.command.startsWith(query));
+  }, [value]);
+  const showSuggestions = suggestions.length > 0 && value.length > 0;
+  const tryPasteImage = useCallback(() => {
+    if (!onImagePaste) return false;
+    setPasteStatus("checking");
+    try {
+      const img = getClipboardImage();
+      if (img) {
+        onImagePaste(img);
+        setPasteStatus("none");
+        return true;
+      }
+    } catch {
+    }
+    setPasteStatus("no_image");
+    setTimeout(() => setPasteStatus("none"), 2e3);
+    return false;
+  }, [onImagePaste]);
+  useEffect(() => {
+    const handler = (data) => {
+      if (isProcessing) return;
+      const str = data.toString();
+      if (str === "\x1Bv" || str === "\x1BV") {
+        tryPasteImage();
+        return;
+      }
+      if (str === "") {
+        tryPasteImage();
+        return;
+      }
+    };
+    process.stdin.on("data", handler);
+    return () => {
+      process.stdin.off("data", handler);
+    };
+  }, [isProcessing, tryPasteImage]);
+  useInput((_input, key) => {
+    if (isProcessing) return;
+    if (!showSuggestions) return;
+    if (key.upArrow) {
+      setSelectedIdx((prev) => Math.max(0, prev - 1));
+    } else if (key.downArrow) {
+      setSelectedIdx((prev) => Math.min(suggestions.length - 1, prev + 1));
+    } else if (key.tab) {
+      const selected = suggestions[selectedIdx];
+      if (selected) {
+        setValue(selected.command + " ");
+        setSelectedIdx(0);
+      }
+    }
+  });
+  const handleChange = useCallback((v) => {
+    setValue(v);
+    setSelectedIdx(0);
+  }, []);
+  const handleSubmit = useCallback((text) => {
+    if (isProcessing) return;
+    if (text.trim().toLowerCase() === "/paste") {
+      tryPasteImage();
+      setValue("");
+      return;
+    }
+    const currentValue = valueRef.current;
+    const currentSuggestions = COMMANDS.filter(
+      (c) => currentValue.startsWith("/") && !currentValue.includes(" ") && c.command.startsWith(currentValue.toLowerCase())
+    );
+    const hasSuggestions = currentSuggestions.length > 0 && currentValue.length > 0;
+    if (hasSuggestions) {
+      const cmd = currentSuggestions[0]?.command;
+      if (cmd && currentValue !== cmd && !currentValue.includes(" ")) {
+        const noArgCmds = ["/clear", "/help", "/status", "/models", "/paste"];
+        setValue(cmd + (noArgCmds.includes(cmd) ? "" : " "));
+        setSelectedIdx(0);
+        return;
+      }
+    }
+    if (text.trim()) {
+      onSubmit(text.trim());
+      setValue("");
+      setSelectedIdx(0);
+    }
+  }, [isProcessing, onSubmit, tryPasteImage]);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    showSuggestions && /* @__PURE__ */ jsx(SuggestionBox, { suggestions, selectedIdx }),
+    imageAttached && /* @__PURE__ */ jsxs(Box, { paddingX: 1, gap: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: "green", bold: true, children: "[image 1]" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "pasted \u2014 send a message to use it" })
+    ] }),
+    pasteStatus === "checking" && /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Checking clipboard..." }) }),
+    pasteStatus === "no_image" && /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: "red", children: "No image found in clipboard. Copy an image first (screenshot, snipping tool, etc.)" }) }),
+    /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: isProcessing ? "yellow" : imageAttached ? "green" : "cyan", paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: isProcessing ? "yellow" : "cyan", bold: true, children: isProcessing ? "\u27F3 " : imageAttached ? "\u{1F4CE} " : "\u276F " }),
+      isProcessing ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Processing..." }) : /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value,
+          onChange: handleChange,
+          onSubmit: handleSubmit,
+          placeholder: imageAttached ? "Describe what you want (image attached)..." : placeholder
+        }
+      )
+    ] })
+  ] });
+});
+var CLASS_ICONS = {
+  Workspace: "\u{1F30D}",
+  ServerScriptService: "\u2699\uFE0F",
+  ReplicatedStorage: "\u{1F4E6}",
+  ReplicatedFirst: "\u{1F680}",
+  StarterGui: "\u{1F5A5}\uFE0F",
+  StarterPack: "\u{1F392}",
+  StarterPlayer: "\u{1F9D1}",
+  Players: "\u{1F465}",
+  Lighting: "\u{1F4A1}",
+  SoundService: "\u{1F50A}",
+  Script: "\u{1F4DC}",
+  LocalScript: "\u{1F4F1}",
+  ModuleScript: "\u{1F4D8}",
+  Part: "\u{1F9F1}",
+  Model: "\u{1F4D0}",
+  Folder: "\u{1F4C1}",
+  RemoteEvent: "\u{1F4E1}",
+  RemoteFunction: "\u{1F4E1}",
+  BindableEvent: "\u{1F517}"
+};
+function getIcon(className) {
+  return CLASS_ICONS[className] ?? "\u25C7";
+}
+var TreeNode = ({ node, depth, maxDepth, selectedPath }) => {
+  const indent = "  ".repeat(depth);
+  const isSelected = node.path === selectedPath;
+  const hasChildren = node.children && node.children.length > 0;
+  const icon = getIcon(node.className);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: indent }),
+      /* @__PURE__ */ jsx(Text, { children: hasChildren ? "\u25BE " : "  " }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        icon,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { bold: isSelected, color: isSelected ? "cyan" : void 0, children: node.name }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " (",
+        node.className,
+        ")"
+      ] })
+    ] }),
+    hasChildren && depth < maxDepth && node.children.map((child, i) => /* @__PURE__ */ jsx(
+      TreeNode,
+      {
+        node: child,
+        depth: depth + 1,
+        maxDepth,
+        selectedPath
+      },
+      `${child.path}-${i}`
+    ))
+  ] });
+};
+var ExplorerPane = React6.memo(({
+  tree,
+  selectedPath,
+  maxDepth = 4
+}) => {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: "gray",
+      paddingX: 1,
+      width: 36,
+      minWidth: 30,
+      children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, dimColor: true, children: "Explorer" }),
+        tree.length === 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, italic: true, children: "Connect Studio plugin..." }) : tree.map((node, i) => /* @__PURE__ */ jsx(
+          TreeNode,
+          {
+            node,
+            depth: 0,
+            maxDepth,
+            selectedPath
+          },
+          `${node.path}-${i}`
+        ))
+      ]
+    }
+  );
+});
+function summarizeArgs(args) {
+  const parts = [];
+  for (const [key, value] of Object.entries(args)) {
+    const str = typeof value === "string" ? value : JSON.stringify(value);
+    parts.push(`${key}=${str.length > 40 ? str.slice(0, 40) + "..." : str}`);
+  }
+  return parts.join(", ");
+}
+var ToolCallView = React6.memo(({ calls }) => {
+  if (calls.length === 0) return null;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 1, children: calls.map((call, i) => /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+    call.status === "running" && /* @__PURE__ */ jsx(Text, { color: "yellow", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
+    call.status === "done" && /* @__PURE__ */ jsx(Text, { color: "green", children: "\u2714" }),
+    call.status === "error" && /* @__PURE__ */ jsx(Text, { color: "red", children: "\u2716" }),
+    /* @__PURE__ */ jsx(Text, { color: "yellow", bold: true, children: call.name }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "(",
+      summarizeArgs(call.args),
+      ")"
+    ] }),
+    call.result && !call.result.success && /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+      " \u2014 ",
+      call.result.error
+    ] })
+  ] }, i)) });
+});
+var Layout = React6.memo(({
+  connected,
+  placeName,
+  model,
+  chatEntries,
+  outputEntries,
+  explorerTree,
+  toolCalls,
+  streaming,
+  isProcessing,
+  onSubmit,
+  onImagePaste,
+  imageAttached,
+  onClearImage
+}) => {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: "100%", children: [
+    /* @__PURE__ */ jsx(StatusBar, { connected, placeName, model }),
+    /* @__PURE__ */ jsxs(Box, { flexGrow: 1, children: [
+      /* @__PURE__ */ jsx(ExplorerPane, { tree: explorerTree }),
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [
+        /* @__PURE__ */ jsx(ChatPane, { entries: chatEntries, streaming }),
+        toolCalls.length > 0 && /* @__PURE__ */ jsx(ToolCallView, { calls: toolCalls })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(OutputPane, { entries: outputEntries, maxLines: 6 }),
+    /* @__PURE__ */ jsx(
+      InputBar,
+      {
+        onSubmit,
+        onImagePaste,
+        isProcessing,
+        imageAttached,
+        onClearImage
+      }
+    )
+  ] });
+});
+
+// src/ui/hooks/useStudio.ts
+init_protocol();
+function useStudio(server) {
+  const connInfo = server.getConnectionInfo();
+  const [state, setState] = useState({
+    connected: server.isConnected(),
+    placeName: connInfo?.placeName,
+    placeId: connInfo?.placeId,
+    explorerTree: [],
+    outputLog: []
+  });
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  useEffect(() => {
+    if (server.isConnected() && !stateRef.current.connected) {
+      const info = server.getConnectionInfo();
+      setState((prev) => ({
+        ...prev,
+        connected: true,
+        placeName: info?.placeName,
+        placeId: info?.placeId
+      }));
+    }
+    const onConnected = (payload) => {
+      setState((prev) => ({
+        ...prev,
+        connected: true,
+        placeName: payload.placeName ?? prev.placeName,
+        placeId: payload.placeId ?? prev.placeId
+      }));
+    };
+    const onDisconnected = () => {
+      setState((prev) => ({
+        ...prev,
+        connected: false,
+        placeName: void 0,
+        placeId: void 0
+      }));
+    };
+    const onExplorer = (payload) => {
+      setState((prev) => ({ ...prev, explorerTree: payload.tree ?? [] }));
+    };
+    const onOutput = (payload) => {
+      setState((prev) => ({
+        ...prev,
+        outputLog: [
+          ...prev.outputLog.slice(-200),
+          {
+            message: payload.message,
+            level: payload.level,
+            timestamp: payload.timestamp ?? Date.now(),
+            source: payload.source
+          }
+        ]
+      }));
+    };
+    const onError = (payload) => {
+      setState((prev) => ({
+        ...prev,
+        outputLog: [
+          ...prev.outputLog.slice(-200),
+          {
+            message: payload.message,
+            level: "error",
+            timestamp: payload.timestamp ?? Date.now(),
+            source: payload.source
+          }
+        ]
+      }));
+    };
+    server.on("studio:connected", onConnected);
+    server.on("studio:disconnected", onDisconnected);
+    server.on(StudioMsg.EXPLORER, onExplorer);
+    server.on(StudioMsg.OUTPUT, onOutput);
+    server.on(StudioMsg.ERROR, onError);
+    return () => {
+      server.off("studio:connected", onConnected);
+      server.off("studio:disconnected", onDisconnected);
+      server.off(StudioMsg.EXPLORER, onExplorer);
+      server.off(StudioMsg.OUTPUT, onOutput);
+      server.off(StudioMsg.ERROR, onError);
+    };
+  }, [server]);
+  const clearOutput = useCallback(() => {
+    setState((prev) => ({ ...prev, outputLog: [] }));
+  }, []);
+  return { ...state, clearOutput };
+}
+
+// src/app.tsx
+init_config();
+var App = ({ server, agent: initialAgent, version }) => {
+  const [showWelcome, setShowWelcome] = useState(true);
+  const [chatEntries, setChatEntries] = useState([]);
+  const [toolCalls, setToolCalls] = useState([]);
+  const [streaming, setStreaming] = useState("");
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [agent, setAgent] = useState(initialAgent);
+  const studio = useStudio(server);
+  const config = loadConfig();
+  const hasApiKey = !!config.apiKey;
+  const [needsSetup, setNeedsSetup] = useState(!hasApiKey);
+  const [pendingImage, setPendingImage] = useState(null);
+  const pendingImageRef = useRef(null);
+  const handleImagePaste = useCallback((image) => {
+    setPendingImage(image);
+    pendingImageRef.current = image;
+  }, []);
+  const handleClearImage = useCallback(() => {
+    setPendingImage(null);
+    pendingImageRef.current = null;
+  }, []);
+  const handleSetupComplete = useCallback((provider, apiKey) => {
+    setConfigValue("provider", provider);
+    setConfigValue("apiKey", apiKey);
+    const providerInfo = PROVIDERS[provider];
+    setConfigValue("apiBaseUrl", providerInfo.baseUrl);
+    setConfigValue("model", providerInfo.defaultModel);
+    setNeedsSetup(false);
+  }, []);
+  const addSystemMessage = useCallback((content) => {
+    setChatEntries((prev) => [
+      ...prev,
+      { role: "system", content, timestamp: Date.now() }
+    ]);
+  }, []);
+  const handleCommand = useCallback(
+    (text) => {
+      const input = text.startsWith("/") ? text.slice(1) : text;
+      const [cmd, ...args] = input.split(" ");
+      const arg = args.join(" ");
+      const lowerCmd = cmd.toLowerCase();
+      const currentModel = agent?.getModel() ?? resolveProviderSettings(config).model;
+      const providerName = PROVIDERS[config.provider]?.name ?? config.provider;
+      const keyStatus = config.apiKey ? `${config.apiKey.slice(0, 6)}...${config.apiKey.slice(-4)}` : "NOT SET";
+      switch (lowerCmd) {
+        case "help":
+        case "h":
+        case "?":
+          addSystemMessage([
+            "\u2500\u2500 Your Config \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+            `  Provider:  ${providerName}`,
+            `  Model:     ${currentModel}`,
+            `  API Key:   ${keyStatus}`,
+            `  Studio:    ${studio.connected ? "\u25CF Connected" + (studio.placeName ? ` (${studio.placeName})` : "") : "\u25CB Disconnected"}`,
+            "",
+            "\u2500\u2500 Commands \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+            "  /help              Show this help",
+            "  /model <name>      Switch AI model",
+            "  /models            List available models",
+            "  /status            Connection status",
+            "  /clear             Clear chat history",
+            "",
+            "\u2500\u2500 Setup (run in your terminal) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+            "  dominus config set provider <name>",
+            "       Providers: openai, anthropic, gemini, xai, openrouter",
+            "  dominus config set apiKey <key>",
+            "  dominus config list",
+            "  dominus install-plugin",
+            "  dominus mcp-install",
+            "",
+            "Or just type a message to chat with Dominus!"
+          ].join("\n"));
+          return true;
+        case "clear":
+          agent?.clearHistory();
+          setChatEntries([]);
+          setToolCalls([]);
+          return true;
+        case "model":
+          if (arg && agent) {
+            agent.setModel(arg);
+            addSystemMessage(`Model switched to: ${arg}`);
+          } else {
+            addSystemMessage("Usage: /model <model-name>");
+          }
+          return true;
+        case "models": {
+          if (!agent) {
+            addSystemMessage("No API key configured \u2014 cannot fetch models.");
+            return true;
+          }
+          addSystemMessage(`Fetching models from ${providerName}...`);
+          agent.listModels().then((models) => {
+            if (models.length === 0) {
+              addSystemMessage("Could not fetch models. Check your API key.");
+              return;
+            }
+            const lines = models.slice(0, 40).map((m) => `  ${m.id}`);
+            addSystemMessage([
+              `\u2500\u2500 ${providerName} Models (${models.length} total) \u2500\u2500`,
+              ...lines,
+              models.length > 40 ? `  ... and ${models.length - 40} more` : "",
+              "",
+              `  Current: ${currentModel}`,
+              "  Switch with: /model <name>"
+            ].join("\n"));
+          });
+          return true;
+        }
+        case "status":
+          addSystemMessage([
+            "\u2500\u2500 Status \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+            `  Provider:  ${providerName}`,
+            `  Model:     ${currentModel}`,
+            `  API Key:   ${keyStatus}`,
+            `  Port:      ${server.getPort()}`,
+            `  Studio:    ${studio.connected ? "\u25CF Connected" + (studio.placeName ? ` (${studio.placeName})` : "") : "\u25CB Disconnected"}`
+          ].join("\n"));
+          return true;
+        default:
+          return false;
+      }
+    },
+    [agent, studio, server, config, addSystemMessage]
+  );
+  const handleSubmit = useCallback(
+    async (text) => {
+      if (isProcessing) return;
+      if (text.trim().toLowerCase() === "/paste" || text.trim().toLowerCase() === "paste") return;
+      const isCommand = text.startsWith("/") || ["help", "h", "?", "clear", "model", "models", "status"].includes(text.split(" ")[0].toLowerCase());
+      if (isCommand) {
+        setShowWelcome(false);
+        handleCommand(text);
+        return;
+      }
+      setShowWelcome(false);
+      if (!agent) {
+        setChatEntries((prev) => [
+          ...prev,
+          { role: "user", content: text, timestamp: Date.now() },
+          {
+            role: "error",
+            content: "No API key configured. Set OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, or XAI_API_KEY \u2014 or run: dominus config set apiKey <key>",
+            timestamp: Date.now()
+          }
+        ]);
+        return;
+      }
+      const image = pendingImageRef.current;
+      setPendingImage(null);
+      pendingImageRef.current = null;
+      setIsProcessing(true);
+      setToolCalls([]);
+      const displayText = image ? `${text}
+[image 1]` : text;
+      setChatEntries((prev) => [
+        ...prev,
+        { role: "user", content: displayText, timestamp: Date.now() }
+      ]);
+      let fullText = "";
+      try {
+        for await (const event of agent.run(text, image ? { base64: image.base64, mimeType: image.mimeType } : void 0)) {
+          switch (event.type) {
+            case "text":
+              fullText += event.content;
+              setStreaming(fullText);
+              break;
+            case "tool_call":
+              setToolCalls((prev) => [
+                ...prev,
+                { name: event.tool, args: event.args, status: "running" }
+              ]);
+              break;
+            case "tool_result":
+              setToolCalls(
+                (prev) => prev.map(
+                  (tc) => tc.name === event.tool && tc.status === "running" ? { ...tc, status: event.result.success ? "done" : "error", result: event.result } : tc
+                )
+              );
+              break;
+            case "error":
+              setChatEntries((prev) => [
+                ...prev,
+                { role: "error", content: event.message, timestamp: Date.now() }
+              ]);
+              break;
+          }
+        }
+        if (fullText) {
+          setChatEntries((prev) => [
+            ...prev,
+            { role: "assistant", content: fullText, timestamp: Date.now() }
+          ]);
+        }
+      } catch (err) {
+        setChatEntries((prev) => [
+          ...prev,
+          {
+            role: "error",
+            content: err instanceof Error ? err.message : String(err),
+            timestamp: Date.now()
+          }
+        ]);
+      } finally {
+        setIsProcessing(false);
+        setStreaming("");
+        setToolCalls([]);
+      }
+    },
+    [agent, isProcessing, handleCommand]
+  );
+  if (needsSetup) {
+    return /* @__PURE__ */ jsx(Setup, { onComplete: handleSetupComplete });
+  }
+  if (showWelcome) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: "100%", children: [
+      /* @__PURE__ */ jsx(
+        Welcome,
+        {
+          userName: config.userName,
+          version,
+          model: resolveProviderSettings(config).model,
+          provider: PROVIDERS[config.provider]?.name ?? config.provider,
+          port: server.getPort(),
+          hasApiKey,
+          connected: studio.connected,
+          cwd: process.cwd()
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        InputBar,
+        {
+          onSubmit: handleSubmit,
+          onImagePaste: handleImagePaste,
+          isProcessing: false,
+          imageAttached: !!pendingImage,
+          onClearImage: handleClearImage,
+          placeholder: hasApiKey ? "Type a message to begin, or Ctrl+V to paste an image..." : "Set up your API key to get started, or type /help..."
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsx(
+    Layout,
+    {
+      connected: studio.connected,
+      placeName: studio.placeName,
+      model: agent?.getModel() ?? resolveProviderSettings(config).model,
+      chatEntries,
+      outputEntries: studio.outputLog,
+      explorerTree: studio.explorerTree,
+      toolCalls,
+      streaming: streaming || void 0,
+      isProcessing,
+      onSubmit: handleSubmit,
+      onImagePaste: handleImagePaste,
+      imageAttached: !!pendingImage,
+      onClearImage: handleClearImage
+    }
+  );
+};
+
+// src/index.tsx
+init_ws_server();
+
+// src/transport/ws-client.ts
+init_protocol();
+var DominusClient = class extends EventEmitter {
+  ws = null;
+  port;
+  studioConnected = false;
+  connectionInfo = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  constructor(port = 18088) {
+    super();
+    this.port = port;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      const url = `ws://localhost:${this.port}`;
+      const ws = new WebSocket(url);
+      ws.on("open", () => {
+        this.ws = ws;
+        ws.send(serializeMessage(createMessage("controller:connect", {})));
+        this.emit("server:started", { port: this.port, relay: true });
+        resolve();
+      });
+      ws.on("message", (raw) => {
+        try {
+          const msg = parseMessage(raw.toString());
+          this.handleMessage(msg);
+        } catch (err) {
+          this.emit("server:error", err);
+        }
+      });
+      ws.on("close", () => {
+        this.ws = null;
+        this.studioConnected = false;
+        this.emit("studio:disconnected");
+        for (const [id, pending] of this.pendingRequests) {
+          clearTimeout(pending.timer);
+          pending.reject(new Error("Relay connection lost"));
+          this.pendingRequests.delete(id);
+        }
+      });
+      ws.on("error", (err) => {
+        if (!this.ws) reject(err);
+        this.emit("server:error", err);
+      });
+    });
+  }
+  handleMessage(msg) {
+    if (msg.type === "controller:welcome") {
+      const p = msg.payload;
+      this.studioConnected = p.studioConnected;
+      if (this.studioConnected) {
+        this.emit("studio:connected", {});
+      }
+      return;
+    }
+    if (msg.type === "studio:connected") {
+      this.studioConnected = true;
+      const payload = msg.payload;
+      this.connectionInfo = {
+        connectedAt: Date.now(),
+        studioVersion: payload.studioVersion,
+        placeId: payload.placeId,
+        placeName: payload.placeName
+      };
+      this.emit("studio:connected", payload);
+      return;
+    }
+    if (msg.type === "studio:disconnected") {
+      this.studioConnected = false;
+      this.connectionInfo = null;
+      this.emit("studio:disconnected");
+      return;
+    }
+    if (msg.type === StudioMsg.RESPONSE) {
+      const pending = this.pendingRequests.get(msg.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        pending.resolve(msg);
+        this.pendingRequests.delete(msg.id);
+      }
+      return;
+    }
+    this.emit(msg.type, msg.payload);
+    this.emit("message", msg);
+  }
+  sendRequest(type, payload, timeoutMs = 1e4) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        reject(new Error("Not connected to Dominus server"));
+        return;
+      }
+      if (!this.studioConnected) {
+        reject(new Error("Studio not connected"));
+        return;
+      }
+      const msg = createMessage(type, payload);
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(msg.id);
+        reject(new Error(`Request timed out: ${type}`));
+      }, timeoutMs);
+      this.pendingRequests.set(msg.id, {
+        resolve,
+        reject,
+        timer
+      });
+      this.ws.send(serializeMessage(msg));
+    });
+  }
+  sendNotification(type, payload) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    const msg = createMessage(type, payload);
+    this.ws.send(serializeMessage(msg));
+  }
+  isConnected() {
+    return this.studioConnected;
+  }
+  getConnectionInfo() {
+    if (!this.connectionInfo) return null;
+    return { ...this.connectionInfo, ws: this.ws };
+  }
+  getPort() {
+    return this.port;
+  }
+  stop() {
+    return new Promise((resolve) => {
+      for (const [, pending] of this.pendingRequests) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("Client shutting down"));
+      }
+      this.pendingRequests.clear();
+      if (this.ws) {
+        this.ws.close();
+        this.ws = null;
+      }
+      resolve();
+    });
+  }
+};
+async function isPortInUse(port) {
+  return new Promise((resolve) => {
+    const ws = new WebSocket(`ws://localhost:${port}`);
+    const timer = setTimeout(() => {
+      ws.close();
+      resolve(false);
+    }, 1e3);
+    ws.on("open", () => {
+      clearTimeout(timer);
+      ws.close();
+      resolve(true);
+    });
+    ws.on("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+
+// 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(tool24) {
+  return {
+    type: "function",
+    function: {
+      name: tool24.name,
+      description: tool24.description,
+      parameters: tool24.parameters
+    }
+  };
+}
+
+// src/agent/system-prompt.ts
+function buildSystemPrompt(opts) {
+  const parts = [];
+  parts.push(`You are Dominus, an expert AI agent for Roblox Studio development.
+You assist ${opts.userName} with building, debugging, and refactoring Roblox experiences.
+
+You are deeply knowledgeable about:
+- Luau (Roblox's programming language): syntax, idioms, metatables, type annotations, coroutines
+- Roblox Engine API: all services (Players, Workspace, DataStoreService, ReplicatedStorage, etc.)
+- Roblox architecture patterns: client-server model, remotes, replication, DataStores
+- Common frameworks: Knit, ProfileService, Rodux, Roact, Fusion
+- Studio workflows: plugins, packages, team collaboration, testing
+- Performance: memory management, heartbeat optimization, streaming, LOD
+
+You have direct access to Roblox Studio through tools. You can read/edit scripts, run code, browse the explorer tree, manage instances, and run tests -- all in real-time via WebSocket.
+
+When the user asks you to do something, you should:
+1. Use your tools to gather context (read scripts, check explorer, recall memory)
+2. Plan your approach for complex tasks
+3. Execute changes using your tools (edit scripts, run code, insert instances)
+4. Verify your changes worked (read back, check output for errors)
+5. Remember important facts for future sessions`);
+  if (opts.connected) {
+    parts.push(`
+## Current Session
+- Studio: CONNECTED${opts.placeName ? ` (${opts.placeName})` : ""}${opts.placeId ? ` [PlaceID: ${opts.placeId}]` : ""}
+- You can use all Studio tools.`);
+  } else {
+    parts.push(`
+## Current Session
+- Studio: NOT CONNECTED
+- You cannot use Studio tools until the plugin connects.
+- You can still use memory tools and answer Roblox questions.`);
+  }
+  if (opts.scriptIndex?.length) {
+    parts.push("\n## Project Scripts");
+    const lines = opts.scriptIndex.map(
+      (s) => `- ${s.path} (${s.className})${s.summary ? `: ${s.summary}` : ""}`
+    );
+    if (lines.length > 40) {
+      parts.push(lines.slice(0, 40).join("\n"));
+      parts.push(`... and ${lines.length - 40} more scripts`);
+    } else {
+      parts.push(lines.join("\n"));
+    }
+  }
+  if (opts.facts?.length) {
+    parts.push("\n## Remembered Context");
+    for (const fact of opts.facts.slice(0, 20)) {
+      parts.push(`- [${fact.category}] ${fact.content}`);
+    }
+  }
+  if (opts.rules) {
+    if (opts.rules.do.length > 0) {
+      parts.push("\n## Rules: DO");
+      for (const rule of opts.rules.do) {
+        parts.push(`- ${rule}`);
+      }
+    }
+    if (opts.rules.dont.length > 0) {
+      parts.push("\n## Rules: DO NOT");
+      for (const rule of opts.rules.dont) {
+        parts.push(`- ${rule}`);
+      }
+    }
+    if (opts.rules.conventions.length > 0) {
+      parts.push("\n## Coding Conventions");
+      for (const conv of opts.rules.conventions) {
+        parts.push(`- ${conv}`);
+      }
+    }
+    if (opts.rules.context) {
+      parts.push(`
+## Project Context
+${opts.rules.context}`);
+    }
+  }
+  parts.push(`
+## Tool Usage Guidelines
+- Always verify your work: after editing a script, read it back to confirm.
+- After running code, check the output for errors.
+- Use remember to store important facts you discover about the project.
+- Use recall_memory before complex tasks to check if you already know relevant context.
+- When searching scripts, be specific with your query terms.
+- For multi-step changes, explain your plan before executing.
+
+## Building & Construction
+When the user asks you to build or create objects (parts, trees, houses, terrain, etc.):
+
+**PREFER these builder tools over raw run_code:**
+- \`create_part\` \u2014 create a single part with position, size, color, material, shape in one call
+- \`build_multiple\` \u2014 create many parts in a single batch round-trip (FASTEST for complex builds)
+- \`clone_instance\` \u2014 duplicate an existing object, optionally offset/rename it
+- \`group_instances\` \u2014 organize parts into a Model or Folder
+- \`set_properties\` \u2014 adjust properties on existing instances (supports Vector3, Color3, enums, hex colors)
+
+**Why use builder tools instead of run_code?**
+- Tool calls are structured \u2014 the AI sends typed parameters, no string interpolation bugs
+- Properties are auto-coerced (hex \u2192 Color3, tables \u2192 Vector3, strings \u2192 Enum values)
+- \`build_multiple\` sends one batch of Luau to Studio, creating many parts in a single round-trip
+- Easier for the agent to plan, verify, and iterate
+
+**Building strategy:**
+1. For a single part: use \`create_part\`
+2. For multi-part objects (trees, buildings, vehicles): use \`build_multiple\` with \`groupName\`
+3. For repeating/duplicating: use \`clone_instance\` with offset
+4. For organizing: use \`group_instances\`
+5. Only fall back to \`run_code\` for complex logic (loops, raycasts, terrain generation algorithms)
+
+## GUI / UI Elements \u2014 CRITICAL
+**ALWAYS use \`create_ui\` for building UI.** It creates the entire UI tree in ONE call \u2014 no run_code, no get_class_info needed.
+Do NOT use run_code for UI creation. Do NOT call get_class_info before create_ui \u2014 it already handles all types natively.
+
+\`create_ui\` takes a declarative JSON tree and builds everything in a single Studio round-trip:
+\`\`\`json
+{
+  "parent": "StarterGui",
+  "tree": {
+    "ClassName": "ScreenGui", "Name": "MyUI", "ResetOnSpawn": false,
+    "Children": [
+      { "ClassName": "Frame", "Size": [1, 0, 1, 0], "BackgroundColor3": "#F0E6FF",
+        "Children": [
+          { "ClassName": "UICorner", "CornerRadius": [0, 12] },
+          { "ClassName": "TextLabel", "Text": "Hello!", "Size": [0.5, 0, 0.1, 0],
+            "Position": [0.25, 0, 0.45, 0], "BackgroundTransparency": 1,
+            "TextColor3": "#6C5CE7", "TextScaled": true, "Font": "GothamBold" }
+        ]
+      }
+    ]
+  }
+}
+\`\`\`
+
+GUI classes use DIFFERENT property types than 3D parts:
+
+**Key type differences:**
+- GUI Size/Position = \`UDim2\` (NOT Vector3). Format: \`{XScale: 0.5, XOffset: 0, YScale: 0.5, YOffset: 0}\` or \`[xScale, xOffset, yScale, yOffset]\`
+- GUI AnchorPoint = \`Vector2\` = \`{x: 0.5, y: 0.5}\`
+- BackgroundColor3 = \`Color3\` = \`"#FF0000"\` or \`{R: 1, G: 0, B: 0}\` or \`"rgb(255,0,0)"\`
+- Font = \`Font\` = \`{Family: "rbxasset://fonts/families/SourceSansPro.json", Weight: "Bold"}\`
+- BorderSizePixel = \`number\`
+- TextSize = \`number\`
+- Enum properties (e.g., TextXAlignment) = string name like \`"Center"\`, \`"Left"\`
+
+**Property coercion handles automatically:**
+- UDim2: tables, arrays, "0.5, 0, 0.3, 0" strings
+- UDim: {Scale, Offset} or number
+- Vector3, Vector2, Color3, BrickColor, CFrame, Rect, NumberRange
+- NumberSequence, ColorSequence (for gradients)
+- All enum properties from string names
+- Color3 from hex "#RRGGBB", "rgb(r,g,b)", or BrickColor name strings
+
+## ReflectionService
+The \`get_class_info\` tool queries Roblox's ReflectionService to return the complete API surface for any class:
+- All properties with their exact ValueType
+- All methods with parameter names and types
+- All events with parameter types
+- Superclass, creatability, serialization info
+
+Use it whenever you're unsure about property names or types. It's fast and cached.`);
+  return parts.join("\n");
+}
+
+// src/agent/context-builder.ts
+init_store();
+init_config();
+
+// src/ai/models.ts
+var POPULAR_MODELS = [
+  // --- OpenAI ---
+  { id: "gpt-5.3-codex", name: "GPT-5.3 Codex", contextWindow: 256e3, supportsTools: true, provider: "openai" },
+  { id: "gpt-5.2", name: "GPT-5.2", contextWindow: 256e3, supportsTools: true, provider: "openai" },
+  { id: "gpt-4o", name: "GPT-4o", contextWindow: 128e3, supportsTools: true, provider: "openai" },
+  { id: "o3-mini", name: "o3-mini", contextWindow: 2e5, supportsTools: true, provider: "openai" },
+  // --- Anthropic ---
+  { id: "claude-opus-4-6", name: "Claude Opus 4.6", contextWindow: 2e5, supportsTools: true, provider: "anthropic" },
+  { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", contextWindow: 2e5, supportsTools: true, provider: "anthropic" },
+  // --- Google Gemini ---
+  { id: "gemini-3.1-pro", name: "Gemini 3.1 Pro", contextWindow: 2097152, supportsTools: true, provider: "gemini" },
+  { id: "gemini-2.0-flash", name: "Gemini 2.0 Flash", contextWindow: 1048576, supportsTools: true, provider: "gemini" },
+  // --- xAI / Grok ---
+  { id: "grok-4.2", name: "Grok 4.2", contextWindow: 256e3, supportsTools: true, provider: "xai" },
+  { id: "grok-3", name: "Grok 3", contextWindow: 131072, supportsTools: true, provider: "xai" },
+  // --- OpenRouter (routes to any model) ---
+  { id: "anthropic/claude-opus-4-6", name: "Claude Opus 4.6", contextWindow: 2e5, supportsTools: true, provider: "openrouter" },
+  { id: "anthropic/claude-sonnet-4-6", name: "Claude Sonnet 4.6", contextWindow: 2e5, supportsTools: true, provider: "openrouter" },
+  { id: "openai/gpt-5.3-codex", name: "GPT-5.3 Codex", contextWindow: 256e3, supportsTools: true, provider: "openrouter" },
+  { id: "openai/gpt-5.2", name: "GPT-5.2", contextWindow: 256e3, supportsTools: true, provider: "openrouter" },
+  { id: "google/gemini-3.1-pro", name: "Gemini 3.1 Pro", contextWindow: 2097152, supportsTools: true, provider: "openrouter" },
+  { id: "x-ai/grok-4.2", name: "Grok 4.2", contextWindow: 256e3, supportsTools: true, provider: "openrouter" },
+  { id: "deepseek/deepseek-v3.2", name: "DeepSeek V3.2", contextWindow: 1e6, supportsTools: true, provider: "openrouter" }
+];
+function getModelInfo(modelId) {
+  return POPULAR_MODELS.find((m) => m.id === modelId);
+}
+function getContextWindow(modelId) {
+  return getModelInfo(modelId)?.contextWindow ?? 128e3;
+}
+
+// src/agent/context-builder.ts
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function buildContext(opts) {
+  const config = loadConfig();
+  const rules = loadRules();
+  const contextWindow = getContextWindow(config.model);
+  const systemBudget = Math.floor(contextWindow * 0.15);
+  const memoryBudget = Math.floor(contextWindow * 0.15);
+  const conversationBudget = Math.floor(contextWindow * 0.45);
+  const connInfo = opts.server.getConnectionInfo();
+  const facts = recallFacts(opts.projectId, opts.userMessage, 15);
+  const scriptIndex = getScriptIndex(opts.projectId);
+  const summaries = getProjectSummaries(opts.projectId, 5);
+  let systemPrompt = buildSystemPrompt({
+    userName: config.userName,
+    connected: opts.server.isConnected(),
+    placeName: connInfo?.placeName,
+    placeId: connInfo?.placeId,
+    scriptIndex,
+    facts,
+    rules
+  });
+  if (estimateTokens(systemPrompt) > systemBudget) {
+    systemPrompt = systemPrompt.slice(0, systemBudget * CHARS_PER_TOKEN);
+  }
+  const messages = [
+    { role: "system", content: systemPrompt }
+  ];
+  if (summaries.length > 0) {
+    const summaryText = summaries.map((s) => s.summary).join("\n");
+    if (estimateTokens(summaryText) <= memoryBudget) {
+      messages.push({
+        role: "system",
+        content: `Previous session summaries:
+${summaryText}`
+      });
+    }
+  }
+  let historyTokens = 0;
+  const historyMessages = [];
+  const currentMsg = {
+    role: "user",
+    content: opts.userMessage
+  };
+  for (let i = opts.conversationHistory.length - 1; i >= 0; i--) {
+    const msg = opts.conversationHistory[i];
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    const tokens = estimateTokens(content);
+    if (historyTokens + tokens > conversationBudget) break;
+    historyTokens += tokens;
+    historyMessages.unshift(msg);
+  }
+  messages.push(...historyMessages, currentMsg);
+  const totalTokens = estimateTokens(
+    messages.map((m) => typeof m.content === "string" ? m.content : "").join("")
+  );
+  return { messages, tokenEstimate: totalTokens };
+}
+
+// src/agent/loop.ts
+init_config();
+init_config();
+init_store();
+var AgentLoop = class {
+  ai;
+  server;
+  tools;
+  conversationHistory = [];
+  projectId = "current";
+  sessionId;
+  maxIterations;
+  maxRetries;
+  constructor(server, tools) {
+    const config = loadConfig();
+    this.ai = new AIProvider(config);
+    this.server = server;
+    this.tools = tools;
+    this.sessionId = nanoid();
+    this.maxIterations = config.maxToolIterations;
+    this.maxRetries = config.maxVerifyRetries;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  setModel(model) {
+    this.ai.setModel(model);
+  }
+  getModel() {
+    return this.ai.getModel();
+  }
+  async listModels() {
+    return this.ai.listModels();
+  }
+  setProjectId(projectId) {
+    this.projectId = projectId;
+  }
+  async *run(userMessage, imageAttachment) {
+    storeMessage({
+      sessionId: this.sessionId,
+      role: "user",
+      content: userMessage + (imageAttachment ? " [image attached]" : ""),
+      createdAt: Date.now()
+    });
+    const { messages } = buildContext({
+      userMessage,
+      conversationHistory: this.conversationHistory,
+      server: this.server,
+      projectId: this.projectId,
+      sessionId: this.sessionId
+    });
+    if (imageAttachment) {
+      const lastMsg = messages[messages.length - 1];
+      if (lastMsg && lastMsg.role === "user") {
+        lastMsg.content = [
+          { type: "text", text: typeof lastMsg.content === "string" ? lastMsg.content : userMessage },
+          {
+            type: "image_url",
+            image_url: {
+              url: `data:${imageAttachment.mimeType};base64,${imageAttachment.base64}`,
+              detail: "high"
+            }
+          }
+        ];
+      }
+    }
+    const toolCtx = this.createToolContext();
+    const allTools = this.tools.getAll();
+    let currentMessages = [...messages];
+    let iteration = 0;
+    while (iteration < this.maxIterations) {
+      iteration++;
+      try {
+        const response = await this.ai.chat(currentMessages, allTools);
+        if (response.content) {
+          yield { type: "text", content: response.content };
+          storeMessage({
+            sessionId: this.sessionId,
+            role: "assistant",
+            content: response.content,
+            createdAt: Date.now()
+          });
+          this.conversationHistory.push({ role: "assistant", content: response.content });
+        }
+        if (response.toolCalls.length === 0) {
+          break;
+        }
+        const toolResults = [];
+        for (const call of response.toolCalls) {
+          yield { type: "tool_call", tool: call.name, args: call.arguments };
+          const result = await this.tools.execute(call, toolCtx);
+          toolResults.push({ call, result });
+          yield { type: "tool_result", tool: call.name, result };
+          storeMessage({
+            sessionId: this.sessionId,
+            role: "tool_call",
+            content: JSON.stringify({ name: call.name, args: call.arguments }),
+            toolName: call.name,
+            createdAt: Date.now()
+          });
+          storeMessage({
+            sessionId: this.sessionId,
+            role: "tool_result",
+            content: JSON.stringify(result),
+            toolName: call.name,
+            createdAt: Date.now()
+          });
+        }
+        const assistantMsg = {
+          role: "assistant",
+          content: response.content ?? null,
+          tool_calls: response.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+          }))
+        };
+        currentMessages.push(assistantMsg);
+        for (const { call, result } of toolResults) {
+          currentMessages.push({
+            role: "tool",
+            content: JSON.stringify(result),
+            tool_call_id: call.id
+          });
+        }
+        this.conversationHistory.push(assistantMsg);
+        for (const { call, result } of toolResults) {
+          this.conversationHistory.push({
+            role: "tool",
+            content: JSON.stringify(result),
+            tool_call_id: call.id
+          });
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        yield { type: "error", message };
+        break;
+      }
+    }
+    yield { type: "done" };
+  }
+  async *streamRun(userMessage, imageAttachment) {
+    for await (const event of this.run(userMessage, imageAttachment)) {
+      yield event;
+    }
+  }
+  createToolContext() {
+    return {
+      sendToStudio: (type, payload, timeoutMs) => {
+        return this.server.sendRequest(type, payload, timeoutMs);
+      },
+      isStudioConnected: () => this.server.isConnected(),
+      memory: {
+        recall: (query, projectId, limit) => {
+          const { recallFacts: recallFacts2 } = (init_store(), __toCommonJS(store_exports));
+          const facts = recallFacts2(projectId || this.projectId, query, limit);
+          return facts.map((f) => f.content);
+        },
+        learn: (projectId, facts) => {
+          const { storeFact: storeFact2 } = (init_store(), __toCommonJS(store_exports));
+          const now = Date.now();
+          for (const f of facts) {
+            storeFact2({
+              projectId: projectId || this.projectId,
+              content: f.content,
+              category: f.category,
+              source: "agent",
+              relevance: 1,
+              createdAt: now,
+              accessedAt: now
+            });
+          }
+        },
+        getScriptIndex: (projectId) => {
+          const { getScriptIndex: getScriptIndex2 } = (init_store(), __toCommonJS(store_exports));
+          return getScriptIndex2(projectId || this.projectId);
+        }
+      },
+      config: createConfigAccess()
+    };
+  }
+  clearHistory() {
+    this.conversationHistory = [];
+    this.sessionId = nanoid();
+  }
+};
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool24) {
+    if (this.tools.has(tool24.name)) {
+      throw new Error(`Tool already registered: ${tool24.name}`);
+    }
+    this.tools.set(tool24.name, tool24);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  getSchemas() {
+    return this.getAll();
+  }
+  async execute(call, ctx) {
+    const tool24 = this.tools.get(call.name);
+    if (!tool24) {
+      return { success: false, error: `Unknown tool: ${call.name}` };
+    }
+    try {
+      return await tool24.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());
+  }
+};
+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_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_recall(), recall_exports)),
+    Promise.resolve().then(() => (init_remember(), remember_exports)),
+    Promise.resolve().then(() => (init_upload_asset(), upload_asset_exports))
+  ];
+  void Promise.all(
+    toolModules.map(async (mod) => {
+      const m = await mod;
+      if (m.tool) registry.register(m.tool);
+    })
+  );
+  return registry;
+}
+
+// src/index.tsx
+init_store();
+init_config();
+var VERSION = "0.1.0";
+var program = new Command();
+program.name("dominus").description("AI-powered autonomous agent for Roblox Studio development").version(VERSION);
+program.command("start", { isDefault: true }).description("Launch the Dominus TUI agent").option("-p, --port <port>", "WebSocket server port", "18088").action(async (opts) => {
+  const config = loadConfig();
+  const port = parseInt(opts.port) || config.port;
+  if (!config.apiKey) {
+    const detected = detectProviderFromEnv();
+    if (detected) {
+      setConfigValue("provider", detected.provider);
+      setConfigValue("apiKey", detected.apiKey);
+    }
+  }
+  if (config.userName === "Developer") {
+    const envUser = process.env.USER || process.env.USERNAME || "Developer";
+    const firstName = envUser.split(" ")[0];
+    if (firstName && firstName !== "Developer") {
+      setConfigValue("userName", firstName);
+    }
+  }
+  await launchApp(port);
+});
+var configCmd = program.command("config").description("Manage Dominus configuration");
+configCmd.command("set <key> <value>").description("Set a config value").action((key, value) => {
+  const numericKeys = ["port", "maxToolIterations", "maxVerifyRetries", "tokenBudget"];
+  const booleanKeys = ["autoIndex", "autoLearn"];
+  const validProviders = ["openai", "anthropic", "gemini", "xai", "openrouter", "custom"];
+  let parsed = value;
+  if (numericKeys.includes(key)) {
+    parsed = parseInt(value);
+  } else if (booleanKeys.includes(key)) {
+    parsed = value === "true";
+  } else if (key === "provider") {
+    if (!validProviders.includes(value)) {
+      console.log(`  \u2716 Invalid provider: ${value}`);
+      console.log(`  Valid providers: ${validProviders.join(", ")}`);
+      return;
+    }
+    const providerInfo = PROVIDERS[value];
+    setConfigValue("apiBaseUrl", providerInfo.baseUrl);
+    setConfigValue("model", providerInfo.defaultModel);
+  }
+  setConfigValue(key, parsed);
+  console.log(`  \u2714 Set ${key} = ${value}`);
+  if (key === "provider") {
+    const p = PROVIDERS[value];
+    console.log(`  \u2192 Base URL: ${p.baseUrl}`);
+    console.log(`  \u2192 Default model: ${p.defaultModel}`);
+  }
+  console.log(`  Config stored at: ${getDominusDir()}/config.json`);
+});
+configCmd.command("get <key>").description("Get a config value").action((key) => {
+  const value = getConfigValue(key);
+  if (key.toLowerCase().includes("key") && typeof value === "string") {
+    console.log(`  ${key} = ${value.slice(0, 8)}...${value.slice(-4)}`);
+  } else {
+    console.log(`  ${key} = ${JSON.stringify(value)}`);
+  }
+});
+configCmd.command("list").description("List all config values").action(() => {
+  const config = loadConfig();
+  console.log("");
+  console.log("  Dominus Configuration:");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const [key, value] of Object.entries(config)) {
+    const display = key.toLowerCase().includes("key") && typeof value === "string" && value.length > 12 ? `${value.slice(0, 8)}...${value.slice(-4)}` : JSON.stringify(value);
+    console.log(`  ${key}: ${display}`);
+  }
+  console.log("");
+  console.log(`  Config file: ${getDominusDir()}/config.json`);
+  console.log("");
+});
+var rulesCmd = program.command("rules").description("Manage agent rules (do/don't)");
+rulesCmd.command("add-do <rule>").description("Add a rule for things Dominus should do").action((rule) => {
+  const rules = loadRules();
+  rules.do.push(rule);
+  saveRules(rules);
+  console.log(`  \u2714 Added DO rule: ${rule}`);
+});
+rulesCmd.command("add-dont <rule>").description("Add a rule for things Dominus should NOT do").action((rule) => {
+  const rules = loadRules();
+  rules.dont.push(rule);
+  saveRules(rules);
+  console.log(`  \u2714 Added DON'T rule: ${rule}`);
+});
+rulesCmd.command("list").description("List all rules").action(() => {
+  const rules = loadRules();
+  console.log("");
+  console.log("  Dominus Rules:");
+  if (rules.do.length) {
+    console.log("  DO:");
+    rules.do.forEach((r, i) => console.log(`    ${i + 1}. ${r}`));
+  }
+  if (rules.dont.length) {
+    console.log("  DON'T:");
+    rules.dont.forEach((r, i) => console.log(`    ${i + 1}. ${r}`));
+  }
+  if (rules.conventions.length) {
+    console.log("  CONVENTIONS:");
+    rules.conventions.forEach((r, i) => console.log(`    ${i + 1}. ${r}`));
+  }
+  if (!rules.do.length && !rules.dont.length && !rules.conventions.length) {
+    console.log("  No rules configured yet.");
+    console.log('  Use: dominus rules add-do "Always use strict typing"');
+    console.log('  Use: dominus rules add-dont "Never use deprecated APIs"');
+  }
+  console.log("");
+});
+program.command("install-plugin").description("Build & install the Dominus plugin into Roblox Studio").action(async () => {
+  const { execSync: execSync2 } = await import('child_process');
+  const packageRoot = path3.resolve(import.meta.dirname ?? __dirname, "..");
+  const pluginDir = path3.join(packageRoot, "plugin");
+  const pluginProject = path3.join(pluginDir, "default.project.json");
+  const studioPlugins = path3.join(
+    os2.homedir(),
+    "AppData",
+    "Local",
+    "Roblox",
+    "Plugins"
+  );
+  const destFile = path3.join(studioPlugins, "Dominus.rbxm");
+  if (!fs4.existsSync(pluginProject)) {
+    console.log("  \u2716 Plugin source not found.");
+    console.log(`  Expected at: ${pluginDir}`);
+    return;
+  }
+  if (!fs4.existsSync(studioPlugins)) {
+    fs4.mkdirSync(studioPlugins, { recursive: true });
+  }
+  let rojoAvailable = false;
+  try {
+    execSync2("rojo --version", { stdio: "pipe" });
+    rojoAvailable = true;
+  } catch {
+  }
+  if (rojoAvailable) {
+    try {
+      console.log("  Building plugin with Rojo...");
+      execSync2(`rojo build "${pluginDir}" -o "${destFile}"`, { stdio: "pipe" });
+      console.log(`  \u2714 Plugin built and installed to: ${destFile}`);
+      console.log("  Restart Roblox Studio to load the plugin.");
+    } catch (err) {
+      console.log(`  \u2716 Rojo build failed: ${err instanceof Error ? err.message : err}`);
+    }
+  } else {
+    console.log("  Rojo not found \u2014 building plugin manually...");
+    buildPluginXml(pluginDir, destFile.replace(".rbxm", ".rbxmx"));
+  }
+});
+program.command("mcp").description("Start the Dominus MCP server (for Cursor, Claude Desktop, etc.)").option("-p, --port <port>", "WebSocket server port for Studio connection", "18088").action(async () => {
+  const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startMcpServer2();
+});
+function getMcpTargets() {
+  const home = os2.homedir();
+  const appData = process.env.APPDATA || path3.join(home, "AppData", "Roaming");
+  const localAppData = process.env.LOCALAPPDATA || path3.join(home, "AppData", "Local");
+  const cwd = process.cwd();
+  return [
+    {
+      name: "Cursor (project)",
+      configPath: path3.join(cwd, ".cursor", "mcp.json"),
+      keyPath: ["mcpServers"]
+    },
+    {
+      name: "Cursor (global)",
+      configPath: path3.join(home, ".cursor", "mcp.json"),
+      keyPath: ["mcpServers"]
+    },
+    {
+      name: "Claude Desktop",
+      configPath: path3.join(appData, "Claude", "claude_desktop_config.json"),
+      keyPath: ["mcpServers"]
+    },
+    {
+      name: "Claude Code",
+      configPath: path3.join(home, ".claude.json"),
+      keyPath: ["mcpServers"]
+    },
+    {
+      name: "Windsurf (project)",
+      configPath: path3.join(cwd, ".windsurf", "mcp.json"),
+      keyPath: ["mcpServers"]
+    },
+    {
+      name: "Windsurf (global)",
+      configPath: path3.join(home, ".codeium", "windsurf", "mcp_config.json"),
+      keyPath: ["mcpServers"]
+    },
+    {
+      name: "VS Code (project)",
+      configPath: path3.join(cwd, ".vscode", "mcp.json"),
+      keyPath: ["servers"]
+    },
+    {
+      name: "VS Code (global)",
+      configPath: path3.join(localAppData, "Code", "User", "settings.json"),
+      keyPath: ["mcp", "servers"]
+    }
+  ];
+}
+var dominusEntry = {
+  command: "dominus",
+  args: ["mcp"],
+  type: "stdio"
+};
+function injectMcpConfig(target) {
+  let config = {};
+  if (fs4.existsSync(target.configPath)) {
+    try {
+      config = JSON.parse(fs4.readFileSync(target.configPath, "utf-8"));
+    } catch {
+      config = {};
+    }
+  }
+  let obj = config;
+  for (const key of target.keyPath) {
+    if (!obj[key] || typeof obj[key] !== "object") {
+      obj[key] = {};
+    }
+    obj = obj[key];
+  }
+  if (obj["dominus"]) {
+    return { status: "already" };
+  }
+  obj["dominus"] = { ...dominusEntry };
+  const dir = path3.dirname(target.configPath);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+  fs4.writeFileSync(target.configPath, JSON.stringify(config, null, 2), "utf-8");
+  return { status: fs4.existsSync(target.configPath) ? "installed" : "created" };
+}
+program.command("mcp-install").description("Auto-install Dominus MCP into Cursor, VS Code, Claude Desktop, Windsurf, etc.").option("-a, --all", "Install to all detected editors").action(async (opts) => {
+  const targets = getMcpTargets();
+  console.log("");
+  console.log("  Dominus MCP Auto-Installer");
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("");
+  if (opts.all) {
+    for (const target of targets) {
+      const result = injectMcpConfig(target);
+      const icon = result.status === "already" ? "\u25CF" : "\u2714";
+      const msg = result.status === "already" ? "already configured" : "installed";
+      console.log(`  ${icon} ${target.name}: ${msg}`);
+    }
+    console.log("");
+    console.log("  Restart your editors to load the Dominus MCP server.");
+    console.log("");
+    return;
+  }
+  const detected = targets.map((t) => ({
+    target: t,
+    exists: fs4.existsSync(path3.dirname(t.configPath))
+  }));
+  const toInstall = detected.filter((d) => d.exists);
+  if (toInstall.length === 0) {
+    console.log("  No supported editors detected.");
+    console.log("  Run with --all to install configs anyway,");
+    console.log("  or manually add to your editor's MCP config:");
+    console.log("");
+    console.log("  {");
+    console.log('    "dominus": {');
+    console.log('      "command": "dominus",');
+    console.log('      "args": ["mcp"]');
+    console.log("    }");
+    console.log("  }");
+    console.log("");
+    return;
+  }
+  console.log("  Detected editors:");
+  console.log("");
+  for (const { target } of toInstall) {
+    const result = injectMcpConfig(target);
+    const icon = result.status === "already" ? "\u25CF" : "\u2714";
+    const msg = result.status === "already" ? "already configured" : "installed";
+    console.log(`  ${icon} ${target.name}: ${msg}`);
+    console.log(`    ${target.configPath}`);
+  }
+  const skipped = detected.filter((d) => !d.exists);
+  if (skipped.length > 0) {
+    console.log("");
+    console.log("  Skipped (not detected):");
+    for (const { target } of skipped) {
+      console.log(`    \u25CB ${target.name}`);
+    }
+  }
+  console.log("");
+  console.log("  Provides 14 Roblox Studio tools to your AI editor.");
+  console.log("  Restart your editors to load the Dominus MCP server.");
+  console.log("");
+});
+program.command("mcp-setup").description("Print MCP configuration for manual setup").action(() => {
+  console.log("");
+  console.log("  Dominus MCP \u2014 Manual Setup");
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("");
+  console.log("  Tip: Run `dominus mcp-install` to auto-install instead!");
+  console.log("");
+  console.log("  Add this to your editor's MCP config:");
+  console.log("");
+  console.log("  {");
+  console.log('    "dominus": {');
+  console.log('      "command": "dominus",');
+  console.log('      "args": ["mcp"]');
+  console.log("    }");
+  console.log("  }");
+  console.log("");
+  console.log("  Config file locations:");
+  console.log("");
+  console.log("    Cursor (project)   .cursor/mcp.json");
+  console.log("    Cursor (global)    ~/.cursor/mcp.json");
+  console.log("    Claude Desktop     %APPDATA%/Claude/claude_desktop_config.json");
+  console.log("    Claude Code        ~/.claude.json");
+  console.log("    Windsurf (project) .windsurf/mcp.json");
+  console.log("    Windsurf (global)  ~/.codeium/windsurf/mcp_config.json");
+  console.log("    VS Code (project)  .vscode/mcp.json");
+  console.log("    VS Code (global)   %LOCALAPPDATA%/Code/User/settings.json");
+  console.log("");
+  console.log("  14 tools: read_script, edit_script, run_code, get_explorer,");
+  console.log("  get_properties, set_properties, insert_instance, delete_instance,");
+  console.log("  get_selection, search_scripts, get_output, run_tests,");
+  console.log("  recall_memory, remember");
+  console.log("");
+});
+function buildPluginXml(pluginDir, destFile) {
+  const srcDir = path3.join(pluginDir, "src");
+  if (!fs4.existsSync(srcDir)) {
+    console.log(`  \u2716 Plugin source directory not found: ${srcDir}`);
+    return;
+  }
+  const files = fs4.readdirSync(srcDir).filter((f) => f.endsWith(".lua"));
+  const mainFile = files.find((f) => f === "init.server.lua");
+  const moduleFiles = files.filter((f) => f !== "init.server.lua");
+  if (!mainFile) {
+    console.log("  \u2716 init.server.lua not found in plugin source");
+    return;
+  }
+  const mainSource = fs4.readFileSync(path3.join(srcDir, mainFile), "utf-8");
+  let moduleItems = "";
+  for (const mf of moduleFiles) {
+    const modName = mf.replace(".lua", "");
+    const modSource = fs4.readFileSync(path3.join(srcDir, mf), "utf-8");
+    moduleItems += `
+      <Item class="ModuleScript" referent="${modName}">
+        <Properties>
+          <string name="Name">${modName}</string>
+          <ProtectedString name="Source"><![CDATA[${modSource}]]></ProtectedString>
+        </Properties>
+      </Item>`;
+  }
+  const rbxmx = `<roblox version="4">
+  <Item class="Script" referent="Dominus">
+    <Properties>
+      <string name="Name">Dominus</string>
+      <ProtectedString name="Source"><![CDATA[${mainSource}]]></ProtectedString>
+      <token name="RunContext">1</token>
+    </Properties>${moduleItems}
+  </Item>
+</roblox>`;
+  fs4.writeFileSync(destFile, rbxmx, "utf-8");
+  console.log(`  \u2714 Plugin installed to: ${destFile}`);
+  console.log("  Restart Roblox Studio to load the plugin.");
+}
+async function launchApp(port) {
+  await initMemoryStore();
+  let server;
+  const portTaken = await isPortInUse(port);
+  if (portTaken) {
+    const client = new DominusClient(port);
+    await client.connect();
+    server = client;
+  } else {
+    const srv = new DominusServer(port);
+    await srv.start();
+    server = srv;
+  }
+  const config = loadConfig();
+  let agent = null;
+  if (config.apiKey) {
+    const tools = createDefaultRegistry();
+    await new Promise((r) => setTimeout(r, 100));
+    agent = new AgentLoop(server, tools);
+  }
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ jsx(App, { server, agent, version: VERSION })
+  );
+  const cleanup = async () => {
+    closeMemoryStore();
+    await server.stop();
+  };
+  process.on("SIGINT", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  await waitUntilExit();
+  await cleanup();
+}
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map