@chrrxs/robloxstudio-mcp-inspector 2.20.0 → 2.22.0

package/dist/index.js

@@ -51,7 +51,26 @@ var init_bridge_service = __esm({
       // Keyed by pluginSessionId (the per-plugin GUID).
       instances = /* @__PURE__ */ new Map();
       instanceAliases = /* @__PURE__ */ new Map();
+      instanceRegisteredListeners = /* @__PURE__ */ new Set();
       requestTimeout = 3e4;
+      onInstanceRegistered(listener) {
+        this.instanceRegisteredListeners.add(listener);
+        for (const instance of this.getPublicInstances()) {
+          try {
+            listener(instance);
+          } catch {
+          }
+        }
+        return () => this.instanceRegisteredListeners.delete(listener);
+      }
+      notifyInstanceRegistered(instance) {
+        for (const listener of this.instanceRegisteredListeners) {
+          try {
+            listener(instance);
+          } catch {
+          }
+        }
+      }
       canonicalInstanceId(instanceId, placeId) {
         return publishedInstanceId(placeId) ?? instanceId;
       }
@@ -157,7 +176,7 @@ var init_bridge_service = __esm({
             }
           };
         }
-        this.instances.set(pluginSessionId, {
+        const registered = {
           pluginSessionId,
           instanceId,
           role: assignedRole,
@@ -171,7 +190,9 @@ var init_bridge_service = __esm({
           versionMismatch,
           lastActivity: Date.now(),
           connectedAt: prior?.connectedAt ?? Date.now()
-        });
+        };
+        this.instances.set(pluginSessionId, registered);
+        this.notifyInstanceRegistered(toPublic(registered));
         return { ok: true, assignedRole, instanceId };
       }
       unregisterInstance(pluginSessionId) {
@@ -369,7 +390,7 @@ var init_bridge_service = __esm({
       async sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs = this.requestTimeout) {
         const requestId = uuidv4();
         const effectiveTimeoutMs = Math.max(1, timeoutMs);
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           const timeoutId = setTimeout(() => {
             if (this.pendingRequests.has(requestId)) {
               this.pendingRequests.delete(requestId);
@@ -384,7 +405,7 @@ var init_bridge_service = __esm({
             targetRole,
             timestamp: Date.now(),
             inFlight: false,
-            resolve: resolve4,
+            resolve: resolve5,
             reject,
             timeoutId,
             timeoutMs: effectiveTimeoutMs
@@ -653,9 +674,57 @@ var init_mcp_compat = __esm({
   }
 });
 
+// ../core/dist/auth.js
+import { randomBytes, createHash, timingSafeEqual } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+function authTokenFilePath() {
+  return join(homedir(), ".robloxstudio-mcp", "auth-token");
+}
+function resolveAuthToken() {
+  const noAuth = (process.env.ROBLOX_STUDIO_NO_AUTH || "").toLowerCase();
+  if (noAuth === "1" || noAuth === "true") {
+    return { source: "disabled" };
+  }
+  const envToken = process.env.ROBLOX_STUDIO_AUTH_TOKEN?.trim();
+  if (envToken) {
+    return { token: envToken, source: "env" };
+  }
+  const filePath = authTokenFilePath();
+  try {
+    if (existsSync(filePath)) {
+      const existing = readFileSync(filePath, "utf8").trim();
+      if (existing) {
+        return { token: existing, source: "file", filePath };
+      }
+    }
+    const fresh = randomBytes(32).toString("hex");
+    mkdirSync(dirname(filePath), { recursive: true, mode: 448 });
+    writeFileSync(filePath, fresh + "\n", { encoding: "utf8", mode: 384 });
+    try {
+      chmodSync(filePath, 384);
+    } catch {
+    }
+    return { token: fresh, source: "file", filePath };
+  } catch (err2) {
+    console.error(`[auth] Could not read/create ${filePath} (${err2 instanceof Error ? err2.message : err2}). Using an in-memory token for this process; set ROBLOX_STUDIO_AUTH_TOKEN to share one across sessions.`);
+    return { token: randomBytes(32).toString("hex"), source: "file" };
+  }
+}
+function tokensMatch(provided, expected) {
+  const a = createHash("sha256").update(provided).digest();
+  const b = createHash("sha256").update(expected).digest();
+  return timingSafeEqual(a, b);
+}
+var init_auth = __esm({
+  "../core/dist/auth.js"() {
+    "use strict";
+  }
+});
+
 // ../core/dist/http-server.js
 import express from "express";
-import cors from "cors";
 import http from "http";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -708,7 +777,7 @@ function requiredClosedLineRange(body, toolName) {
   }
   return { startLine: parsed.startLine, endLine: parsed.endLine };
 }
-function createHttpServer(tools, bridge, allowedTools, serverConfig) {
+function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   const app = express();
   let mcpServerActive = false;
   let lastMCPActivity = 0;
@@ -738,7 +807,49 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
   const isPluginConnected = () => {
     return bridge.getInstances().length > 0;
   };
-  app.use(cors());
+  const allowedOrigins = new Set(security?.allowedOrigins ?? []);
+  app.use((req, res, next) => {
+    const origin = req.headers.origin;
+    if (typeof origin !== "string" || origin === "") {
+      next();
+      return;
+    }
+    if (!allowedOrigins.has(origin)) {
+      res.status(403).json({
+        error: "forbidden_origin",
+        message: `Cross-origin requests are not allowed from ${origin}. Set ROBLOX_STUDIO_ALLOWED_ORIGINS to allowlist specific origins.`
+      });
+      return;
+    }
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, X-MCP-Auth, Mcp-Protocol-Version");
+    if (req.method === "OPTIONS") {
+      res.status(204).end();
+      return;
+    }
+    next();
+  });
+  const authToken = security?.authToken;
+  const authRequired = (path6) => path6 === "/mcp" || path6.startsWith("/mcp/") || path6 === "/proxy" || path6 === "/instances" || path6 === "/unregister-instance-id";
+  app.use((req, res, next) => {
+    if (!authToken || !authRequired(req.path)) {
+      next();
+      return;
+    }
+    const headerToken = req.headers["x-mcp-auth"];
+    const bearer = typeof req.headers.authorization === "string" && req.headers.authorization.startsWith("Bearer ") ? req.headers.authorization.slice("Bearer ".length) : void 0;
+    const provided = typeof headerToken === "string" && headerToken !== "" ? headerToken : bearer;
+    if (provided !== void 0 && tokensMatch(provided, authToken)) {
+      next();
+      return;
+    }
+    res.status(401).json({
+      error: "unauthorized",
+      message: 'Missing or invalid auth token. Send it as "X-MCP-Auth: <token>" or "Authorization: Bearer <token>". ' + (security?.authTokenHint ?? "The token is in ~/.robloxstudio-mcp/auth-token (or ROBLOX_STUDIO_AUTH_TOKEN).")
+    });
+  });
   app.use(express.json({ limit: "50mb" }));
   app.use(express.urlencoded({ limit: "50mb", extended: true }));
   app.get("/health", (req, res) => {
@@ -801,11 +912,11 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
         pluginVariant: typeof pluginVariant === "string" ? pluginVariant : "unknown",
         serverVersion: serverConfig?.version ?? ""
       });
-    } catch (err) {
+    } catch (err2) {
       res.status(500).json({
         success: false,
         error: "ready_registration_exception",
-        message: err instanceof Error ? err.message : String(err),
+        message: err2 instanceof Error ? err2.message : String(err2),
         request: requestContext
       });
       return;
@@ -956,8 +1067,8 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
     try {
       const response = await bridge.sendRequest(endpoint, data, targetInstanceId, targetRole);
       res.json({ response });
-    } catch (err) {
-      res.status(500).json({ error: err.message || "Proxy request failed" });
+    } catch (err2) {
+      res.status(500).json({ error: err2.message || "Proxy request failed" });
     }
   });
   if (serverConfig) {
@@ -1069,19 +1180,19 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
   return app;
 }
 function listenWithRetry(app, host, startPort, maxAttempts = 5) {
-  return new Promise(async (resolve4, reject) => {
+  return new Promise(async (resolve5, reject) => {
     for (let i = 0; i < maxAttempts; i++) {
       const port = startPort + i;
       try {
         const server = await bindPort(app, host, port);
-        resolve4({ server, port });
+        resolve5({ server, port });
         return;
-      } catch (err) {
-        if (err.code === "EADDRINUSE") {
+      } catch (err2) {
+        if (err2.code === "EADDRINUSE") {
           console.error(`Port ${port} in use, trying next...`);
           continue;
         }
-        reject(err);
+        reject(err2);
         return;
       }
     }
@@ -1089,16 +1200,16 @@ function listenWithRetry(app, host, startPort, maxAttempts = 5) {
   });
 }
 function bindPort(app, host, port) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const server = http.createServer(app);
-    const onError = (err) => {
+    const onError = (err2) => {
       server.removeListener("error", onError);
-      reject(err);
+      reject(err2);
     };
     server.once("error", onError);
     server.listen(port, host, () => {
       server.removeListener("error", onError);
-      resolve4(server);
+      resolve5(server);
     });
   });
 }
@@ -1108,7 +1219,9 @@ var init_http_server = __esm({
     "use strict";
     init_bridge_service();
     init_mcp_compat();
+    init_auth();
     TOOL_HANDLERS = {
+      get_roblox_skills: (tools, body) => tools.getRobloxSkills(body.action, body.name),
       get_roblox_docs: (tools, body) => tools.getRobloxDocs(body.name, body.doc_type, body.section),
       get_file_tree: (tools, body) => tools.getFileTree(body.path, body.instance_id),
       search_files: (tools, body) => tools.searchFiles(body.query, body.searchType, body.instance_id),
@@ -1275,8 +1388,844 @@ var init_studio_client = __esm({
   }
 });
 
+// ../core/dist/tools/build-interpreter.js
+import * as acorn from "acorn";
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function runRestrictedScript(code, globals, options) {
+  const timeoutMs = options?.timeoutMs ?? 1e4;
+  const maxOps = options?.maxOps ?? 2e7;
+  const deadline = Date.now() + timeoutMs;
+  let ops = 0;
+  let ast;
+  try {
+    ast = acorn.parse(code, { ecmaVersion: 2022, sourceType: "script" });
+  } catch (err2) {
+    throw new Error(`Syntax error: ${err2.message}`);
+  }
+  const globalScope = new Scope(void 0, true);
+  for (const [name, value] of Object.entries(globals)) {
+    globalScope.declare(name, value, "const");
+  }
+  function tick() {
+    ops++;
+    if (ops > maxOps) {
+      throw new ScriptTimeoutError(`Operation budget exceeded (${maxOps} ops)`);
+    }
+    if ((ops & 8191) === 0 && Date.now() > deadline) {
+      throw new ScriptTimeoutError(`Execution timed out after ${timeoutMs}ms`);
+    }
+  }
+  function assertPropAllowed(prop) {
+    const name = typeof prop === "symbol" ? String(prop) : String(prop);
+    if (FORBIDDEN_PROPS.has(name)) {
+      throw new Error(`Access to property "${name}" is not allowed`);
+    }
+    return name;
+  }
+  function getMember(obj, prop) {
+    if (obj === null || obj === void 0) {
+      throw new Error(`Cannot read property "${String(prop)}" of ${obj}`);
+    }
+    const name = assertPropAllowed(prop);
+    if (Array.isArray(obj)) {
+      if (name === "length")
+        return obj.length;
+      const idx = Number(name);
+      if (Number.isInteger(idx) && idx >= 0)
+        return obj[idx];
+      if (ARRAY_MEMBERS.has(name))
+        return obj[name];
+      throw new Error(`Array method "${name}" is not allowed`);
+    }
+    if (typeof obj === "string") {
+      if (name === "length")
+        return obj.length;
+      const idx = Number(name);
+      if (Number.isInteger(idx) && idx >= 0)
+        return obj[idx];
+      if (STRING_MEMBERS.has(name))
+        return obj[name];
+      throw new Error(`String method "${name}" is not allowed`);
+    }
+    if (typeof obj === "number") {
+      if (NUMBER_MEMBERS.has(name))
+        return obj[name];
+      throw new Error(`Number method "${name}" is not allowed`);
+    }
+    if (isPlainObject(obj)) {
+      if (Object.prototype.hasOwnProperty.call(obj, name))
+        return obj[name];
+      return void 0;
+    }
+    throw new Error(`Property access on this value type is not allowed`);
+  }
+  function setMember(obj, prop, value) {
+    if (obj === null || obj === void 0) {
+      throw new Error(`Cannot set property "${String(prop)}" of ${obj}`);
+    }
+    const name = assertPropAllowed(prop);
+    if (Object.isFrozen(obj)) {
+      throw new Error(`Cannot assign to property "${name}" of a frozen object`);
+    }
+    if (Array.isArray(obj)) {
+      const idx = Number(name);
+      if (Number.isInteger(idx) && idx >= 0 || name === "length") {
+        obj[name] = value;
+        return;
+      }
+      throw new Error(`Cannot set property "${name}" on an array`);
+    }
+    if (isPlainObject(obj)) {
+      obj[name] = value;
+      return;
+    }
+    throw new Error(`Property assignment on this value type is not allowed`);
+  }
+  function callFunction(fn, thisArg, args, desc) {
+    if (typeof fn !== "function") {
+      throw new Error(`${desc} is not a function`);
+    }
+    return fn.apply(thisArg, args);
+  }
+  function bindPattern(pattern, value, scope, kind) {
+    switch (pattern.type) {
+      case "Identifier":
+        scope.declare(pattern.name, value, kind);
+        return;
+      case "AssignmentPattern":
+        bindPattern(pattern.left, value === void 0 ? evaluate(pattern.right, scope) : value, scope, kind);
+        return;
+      case "ArrayPattern": {
+        if (value === null || value === void 0)
+          throw new Error("Cannot destructure null/undefined");
+        let i = 0;
+        for (const el of pattern.elements) {
+          if (el === null) {
+            i++;
+            continue;
+          }
+          if (el.type === "RestElement") {
+            bindPattern(el.argument, Array.isArray(value) ? value.slice(i) : [], scope, kind);
+            break;
+          }
+          bindPattern(el, getMember(value, i), scope, kind);
+          i++;
+        }
+        return;
+      }
+      case "ObjectPattern": {
+        if (value === null || value === void 0)
+          throw new Error("Cannot destructure null/undefined");
+        const used = /* @__PURE__ */ new Set();
+        for (const propNode of pattern.properties) {
+          if (propNode.type === "RestElement") {
+            const rest = {};
+            if (isPlainObject(value)) {
+              for (const k of Object.keys(value)) {
+                if (!used.has(k) && !FORBIDDEN_PROPS.has(k))
+                  rest[k] = value[k];
+              }
+            }
+            bindPattern(propNode.argument, rest, scope, kind);
+            continue;
+          }
+          const key = propNode.computed ? String(evaluate(propNode.key, scope)) : propNode.key.type === "Identifier" ? propNode.key.name : String(propNode.key.value);
+          used.add(key);
+          bindPattern(propNode.value, getMember(value, key), scope, kind);
+        }
+        return;
+      }
+      default:
+        throw new Error(`Unsupported binding pattern: ${pattern.type}`);
+    }
+  }
+  function makeFunction(node, closureScope) {
+    return (...args) => {
+      tick();
+      const fnScope = new Scope(closureScope, true);
+      node.params.forEach((param, i) => {
+        if (param.type === "RestElement") {
+          bindPattern(param.argument, args.slice(i), fnScope, "let");
+        } else {
+          bindPattern(param, args[i], fnScope, "let");
+        }
+      });
+      try {
+        if (node.body.type === "BlockStatement") {
+          executeBlock(node.body.body, new Scope(fnScope));
+          return void 0;
+        }
+        return evaluate(node.body, fnScope);
+      } catch (signal) {
+        if (signal instanceof ReturnSignal)
+          return signal.value;
+        throw signal;
+      }
+    };
+  }
+  function hoistFunctions(statements, scope) {
+    for (const stmt of statements) {
+      if (stmt.type === "FunctionDeclaration" && stmt.id) {
+        if (stmt.async || stmt.generator)
+          throw new Error("async/generator functions are not supported");
+        scope.declare(stmt.id.name, makeFunction(stmt, scope), "let");
+      }
+    }
+  }
+  function executeBlock(statements, scope) {
+    hoistFunctions(statements, scope);
+    for (const stmt of statements) {
+      execute(stmt, scope);
+    }
+  }
+  function execute(node, scope) {
+    tick();
+    switch (node.type) {
+      case "ExpressionStatement":
+        evaluate(node.expression, scope);
+        return;
+      case "VariableDeclaration":
+        for (const decl of node.declarations) {
+          const value = decl.init ? evaluate(decl.init, scope) : void 0;
+          bindPattern(decl.id, value, scope, node.kind);
+        }
+        return;
+      case "FunctionDeclaration":
+        return;
+      // hoisted by executeBlock
+      case "BlockStatement":
+        executeBlock(node.body, new Scope(scope));
+        return;
+      case "EmptyStatement":
+        return;
+      case "IfStatement":
+        if (evaluate(node.test, scope)) {
+          execute(node.consequent, scope);
+        } else if (node.alternate) {
+          execute(node.alternate, scope);
+        }
+        return;
+      case "ForStatement": {
+        const forScope = new Scope(scope);
+        if (node.init) {
+          if (node.init.type === "VariableDeclaration")
+            execute(node.init, forScope);
+          else
+            evaluate(node.init, forScope);
+        }
+        while (node.test === null || evaluate(node.test, forScope)) {
+          tick();
+          try {
+            execute(node.body, new Scope(forScope));
+          } catch (signal) {
+            if (signal instanceof BreakSignal)
+              break;
+            if (!(signal instanceof ContinueSignal))
+              throw signal;
+          }
+          if (node.update)
+            evaluate(node.update, forScope);
+        }
+        return;
+      }
+      case "ForOfStatement": {
+        const iterable = evaluate(node.right, scope);
+        if (!Array.isArray(iterable) && typeof iterable !== "string") {
+          throw new Error("for...of only supports arrays and strings");
+        }
+        for (const item of iterable) {
+          tick();
+          const iterScope = new Scope(scope);
+          if (node.left.type === "VariableDeclaration") {
+            bindPattern(node.left.declarations[0].id, item, iterScope, node.left.kind);
+          } else {
+            assignTo(node.left, item, iterScope);
+          }
+          try {
+            execute(node.body, iterScope);
+          } catch (signal) {
+            if (signal instanceof BreakSignal)
+              break;
+            if (!(signal instanceof ContinueSignal))
+              throw signal;
+          }
+        }
+        return;
+      }
+      case "ForInStatement": {
+        const obj = evaluate(node.right, scope);
+        const keys = isPlainObject(obj) ? Object.keys(obj) : Array.isArray(obj) ? obj.map((_, i) => String(i)) : [];
+        for (const key of keys) {
+          tick();
+          const iterScope = new Scope(scope);
+          if (node.left.type === "VariableDeclaration") {
+            bindPattern(node.left.declarations[0].id, key, iterScope, node.left.kind);
+          } else {
+            assignTo(node.left, key, iterScope);
+          }
+          try {
+            execute(node.body, iterScope);
+          } catch (signal) {
+            if (signal instanceof BreakSignal)
+              break;
+            if (!(signal instanceof ContinueSignal))
+              throw signal;
+          }
+        }
+        return;
+      }
+      case "WhileStatement":
+        while (evaluate(node.test, scope)) {
+          tick();
+          try {
+            execute(node.body, new Scope(scope));
+          } catch (signal) {
+            if (signal instanceof BreakSignal)
+              break;
+            if (!(signal instanceof ContinueSignal))
+              throw signal;
+          }
+        }
+        return;
+      case "DoWhileStatement":
+        do {
+          tick();
+          try {
+            execute(node.body, new Scope(scope));
+          } catch (signal) {
+            if (signal instanceof BreakSignal)
+              break;
+            if (!(signal instanceof ContinueSignal))
+              throw signal;
+          }
+        } while (evaluate(node.test, scope));
+        return;
+      case "BreakStatement":
+        throw new BreakSignal(node.label?.name);
+      case "ContinueStatement":
+        throw new ContinueSignal(node.label?.name);
+      case "ReturnStatement":
+        throw new ReturnSignal(node.argument ? evaluate(node.argument, scope) : void 0);
+      case "ThrowStatement":
+        throw evaluate(node.argument, scope);
+      case "TryStatement": {
+        try {
+          execute(node.block, scope);
+        } catch (err2) {
+          if (err2 instanceof BreakSignal || err2 instanceof ContinueSignal || err2 instanceof ReturnSignal)
+            throw err2;
+          if (err2 instanceof ScriptTimeoutError)
+            throw err2;
+          if (node.handler) {
+            const catchScope = new Scope(scope);
+            if (node.handler.param) {
+              const message = err2 instanceof Error ? { message: err2.message } : err2;
+              bindPattern(node.handler.param, message, catchScope, "let");
+            }
+            execute(node.handler.body, catchScope);
+          }
+        } finally {
+          if (node.finalizer)
+            execute(node.finalizer, scope);
+        }
+        return;
+      }
+      case "SwitchStatement": {
+        const disc = evaluate(node.discriminant, scope);
+        const switchScope = new Scope(scope);
+        let matched = false;
+        try {
+          for (const caseNode of node.cases) {
+            if (!matched) {
+              if (caseNode.test === null)
+                matched = true;
+              else if (evaluate(caseNode.test, switchScope) === disc)
+                matched = true;
+            }
+            if (matched) {
+              for (const stmt of caseNode.consequent)
+                execute(stmt, switchScope);
+            }
+          }
+        } catch (signal) {
+          if (!(signal instanceof BreakSignal))
+            throw signal;
+        }
+        return;
+      }
+      case "LabeledStatement":
+        try {
+          execute(node.body, scope);
+        } catch (signal) {
+          if (signal instanceof BreakSignal && signal.label === node.label.name)
+            return;
+          throw signal;
+        }
+        return;
+      default:
+        throw new Error(`Unsupported statement: ${node.type}`);
+    }
+  }
+  function assignTo(target, value, scope) {
+    if (target.type === "Identifier") {
+      scope.set(target.name, value);
+    } else if (target.type === "MemberExpression") {
+      const obj = evaluate(target.object, scope);
+      const prop = target.computed ? evaluate(target.property, scope) : target.property.name;
+      setMember(obj, prop, value);
+    } else {
+      throw new Error(`Unsupported assignment target: ${target.type}`);
+    }
+  }
+  function evaluate(node, scope) {
+    tick();
+    switch (node.type) {
+      case "Literal":
+        if (node.regex)
+          throw new Error("Regular expression literals are not supported");
+        return node.value;
+      case "TemplateLiteral": {
+        let out = "";
+        node.quasis.forEach((quasi, i) => {
+          out += quasi.value.cooked ?? "";
+          if (i < node.expressions.length)
+            out += String(evaluate(node.expressions[i], scope));
+        });
+        return out;
+      }
+      case "Identifier":
+        return scope.get(node.name);
+      case "ArrayExpression": {
+        const arr = [];
+        for (const el of node.elements) {
+          if (el === null) {
+            arr.length++;
+            continue;
+          }
+          if (el.type === "SpreadElement") {
+            const spread = evaluate(el.argument, scope);
+            if (!Array.isArray(spread) && typeof spread !== "string") {
+              throw new Error("Spread only supports arrays and strings");
+            }
+            for (const item of spread)
+              arr.push(item);
+          } else {
+            arr.push(evaluate(el, scope));
+          }
+        }
+        return arr;
+      }
+      case "ObjectExpression": {
+        const obj = {};
+        for (const prop of node.properties) {
+          if (prop.type === "SpreadElement") {
+            const spread = evaluate(prop.argument, scope);
+            if (isPlainObject(spread)) {
+              for (const k of Object.keys(spread)) {
+                if (!FORBIDDEN_PROPS.has(k))
+                  obj[k] = spread[k];
+              }
+            }
+            continue;
+          }
+          if (prop.kind !== "init")
+            throw new Error("Getters/setters are not supported");
+          const key = prop.computed ? String(evaluate(prop.key, scope)) : prop.key.type === "Identifier" ? prop.key.name : String(prop.key.value);
+          assertPropAllowed(key);
+          obj[key] = evaluate(prop.value, scope);
+        }
+        return obj;
+      }
+      case "ArrowFunctionExpression":
+      case "FunctionExpression":
+        if (node.async || node.generator)
+          throw new Error("async/generator functions are not supported");
+        return makeFunction(node, scope);
+      case "UnaryExpression": {
+        if (node.operator === "typeof" && node.argument.type === "Identifier" && !scope.has(node.argument.name)) {
+          return "undefined";
+        }
+        if (node.operator === "delete") {
+          if (node.argument.type !== "MemberExpression")
+            return true;
+          const obj = evaluate(node.argument.object, scope);
+          const prop = node.argument.computed ? evaluate(node.argument.property, scope) : node.argument.property.name;
+          const name = assertPropAllowed(prop);
+          if (isPlainObject(obj) && !Object.isFrozen(obj)) {
+            delete obj[name];
+            return true;
+          }
+          throw new Error("delete is only allowed on plain objects");
+        }
+        const arg = evaluate(node.argument, scope);
+        switch (node.operator) {
+          case "-":
+            return -arg;
+          case "+":
+            return +arg;
+          case "!":
+            return !arg;
+          case "~":
+            return ~arg;
+          case "typeof":
+            return typeof arg;
+          case "void":
+            return void 0;
+          default:
+            throw new Error(`Unsupported unary operator: ${node.operator}`);
+        }
+      }
+      case "UpdateExpression": {
+        const old = node.argument.type === "Identifier" ? scope.get(node.argument.name) : getMember(evaluate(node.argument.object, scope), node.argument.computed ? evaluate(node.argument.property, scope) : node.argument.property.name);
+        const next = node.operator === "++" ? old + 1 : old - 1;
+        assignTo(node.argument, next, scope);
+        return node.prefix ? next : old;
+      }
+      case "BinaryExpression": {
+        if (node.operator === "in") {
+          const key = assertPropAllowed(evaluate(node.left, scope));
+          const obj = evaluate(node.right, scope);
+          if (isPlainObject(obj))
+            return Object.prototype.hasOwnProperty.call(obj, key);
+          if (Array.isArray(obj))
+            return Number(key) >= 0 && Number(key) < obj.length;
+          throw new Error('"in" is only supported on plain objects and arrays');
+        }
+        if (node.operator === "instanceof")
+          throw new Error("instanceof is not supported");
+        const l = evaluate(node.left, scope);
+        const r = evaluate(node.right, scope);
+        switch (node.operator) {
+          case "+":
+            return l + r;
+          case "-":
+            return l - r;
+          case "*":
+            return l * r;
+          case "/":
+            return l / r;
+          case "%":
+            return l % r;
+          case "**":
+            return l ** r;
+          case "==":
+            return l == r;
+          // eslint-disable-line eqeqeq
+          case "!=":
+            return l != r;
+          // eslint-disable-line eqeqeq
+          case "===":
+            return l === r;
+          case "!==":
+            return l !== r;
+          case "<":
+            return l < r;
+          case "<=":
+            return l <= r;
+          case ">":
+            return l > r;
+          case ">=":
+            return l >= r;
+          case "&":
+            return l & r;
+          case "|":
+            return l | r;
+          case "^":
+            return l ^ r;
+          case "<<":
+            return l << r;
+          case ">>":
+            return l >> r;
+          case ">>>":
+            return l >>> r;
+          default:
+            throw new Error(`Unsupported binary operator: ${node.operator}`);
+        }
+      }
+      case "LogicalExpression": {
+        const l = evaluate(node.left, scope);
+        if (node.operator === "&&")
+          return l ? evaluate(node.right, scope) : l;
+        if (node.operator === "||")
+          return l ? l : evaluate(node.right, scope);
+        if (node.operator === "??")
+          return l ?? evaluate(node.right, scope);
+        throw new Error(`Unsupported logical operator: ${node.operator}`);
+      }
+      case "AssignmentExpression": {
+        let value;
+        if (node.operator === "=") {
+          value = evaluate(node.right, scope);
+        } else {
+          const current = node.left.type === "Identifier" ? scope.get(node.left.name) : getMember(evaluate(node.left.object, scope), node.left.computed ? evaluate(node.left.property, scope) : node.left.property.name);
+          const rhs = () => evaluate(node.right, scope);
+          switch (node.operator) {
+            case "+=":
+              value = current + rhs();
+              break;
+            case "-=":
+              value = current - rhs();
+              break;
+            case "*=":
+              value = current * rhs();
+              break;
+            case "/=":
+              value = current / rhs();
+              break;
+            case "%=":
+              value = current % rhs();
+              break;
+            case "**=":
+              value = current ** rhs();
+              break;
+            case "&=":
+              value = current & rhs();
+              break;
+            case "|=":
+              value = current | rhs();
+              break;
+            case "^=":
+              value = current ^ rhs();
+              break;
+            case "<<=":
+              value = current << rhs();
+              break;
+            case ">>=":
+              value = current >> rhs();
+              break;
+            case ">>>=":
+              value = current >>> rhs();
+              break;
+            case "&&=":
+              value = current ? rhs() : current;
+              break;
+            case "||=":
+              value = current ? current : rhs();
+              break;
+            case "??=":
+              value = current ?? rhs();
+              break;
+            default:
+              throw new Error(`Unsupported assignment operator: ${node.operator}`);
+          }
+        }
+        assignTo(node.left, value, scope);
+        return value;
+      }
+      case "ConditionalExpression":
+        return evaluate(node.test, scope) ? evaluate(node.consequent, scope) : evaluate(node.alternate, scope);
+      case "CallExpression": {
+        const args = [];
+        for (const argNode of node.arguments) {
+          if (argNode.type === "SpreadElement") {
+            const spread = evaluate(argNode.argument, scope);
+            if (!Array.isArray(spread) && typeof spread !== "string") {
+              throw new Error("Spread only supports arrays and strings");
+            }
+            for (const item of spread)
+              args.push(item);
+          } else {
+            args.push(evaluate(argNode, scope));
+          }
+        }
+        if (node.callee.type === "MemberExpression") {
+          const obj = evaluate(node.callee.object, scope);
+          if (node.optional && (obj === null || obj === void 0))
+            return void 0;
+          const prop = node.callee.computed ? evaluate(node.callee.property, scope) : node.callee.property.name;
+          const method = getMember(obj, prop);
+          if (node.callee.optional && (method === null || method === void 0))
+            return void 0;
+          return callFunction(method, obj, args, `${String(prop)}`);
+        }
+        const fn = evaluate(node.callee, scope);
+        if (node.optional && (fn === null || fn === void 0))
+          return void 0;
+        const desc = node.callee.type === "Identifier" ? node.callee.name : "expression";
+        return callFunction(fn, void 0, args, desc);
+      }
+      case "MemberExpression": {
+        const obj = evaluate(node.object, scope);
+        if (node.optional && (obj === null || obj === void 0))
+          return void 0;
+        const prop = node.computed ? evaluate(node.property, scope) : node.property.name;
+        return getMember(obj, prop);
+      }
+      case "ChainExpression":
+        return evaluate(node.expression, scope);
+      case "SequenceExpression": {
+        let result;
+        for (const expr of node.expressions)
+          result = evaluate(expr, scope);
+        return result;
+      }
+      case "NewExpression":
+        throw new Error('"new" is not supported in build code');
+      case "ThisExpression":
+        throw new Error('"this" is not supported in build code');
+      case "AwaitExpression":
+        throw new Error("await is not supported in build code");
+      case "TaggedTemplateExpression":
+        throw new Error("Tagged templates are not supported in build code");
+      default:
+        throw new Error(`Unsupported expression: ${node.type}`);
+    }
+  }
+  executeBlock(ast.body, globalScope);
+}
+var ScriptTimeoutError, BreakSignal, ContinueSignal, ReturnSignal, FORBIDDEN_PROPS, ARRAY_MEMBERS, STRING_MEMBERS, NUMBER_MEMBERS, Scope;
+var init_build_interpreter = __esm({
+  "../core/dist/tools/build-interpreter.js"() {
+    "use strict";
+    ScriptTimeoutError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ScriptTimeoutError";
+      }
+    };
+    BreakSignal = class {
+      label;
+      constructor(label) {
+        this.label = label;
+      }
+    };
+    ContinueSignal = class {
+      label;
+      constructor(label) {
+        this.label = label;
+      }
+    };
+    ReturnSignal = class {
+      value;
+      constructor(value) {
+        this.value = value;
+      }
+    };
+    FORBIDDEN_PROPS = /* @__PURE__ */ new Set([
+      "__proto__",
+      "constructor",
+      "prototype",
+      "__defineGetter__",
+      "__defineSetter__",
+      "__lookupGetter__",
+      "__lookupSetter__",
+      "caller",
+      "callee",
+      "arguments",
+      "bind",
+      "call",
+      "apply"
+    ]);
+    ARRAY_MEMBERS = /* @__PURE__ */ new Set([
+      "length",
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "slice",
+      "splice",
+      "indexOf",
+      "lastIndexOf",
+      "includes",
+      "join",
+      "map",
+      "filter",
+      "forEach",
+      "reduce",
+      "reduceRight",
+      "concat",
+      "reverse",
+      "sort",
+      "find",
+      "findIndex",
+      "some",
+      "every",
+      "flat",
+      "flatMap",
+      "fill"
+    ]);
+    STRING_MEMBERS = /* @__PURE__ */ new Set([
+      "length",
+      "charAt",
+      "charCodeAt",
+      "codePointAt",
+      "indexOf",
+      "lastIndexOf",
+      "includes",
+      "startsWith",
+      "endsWith",
+      "slice",
+      "substring",
+      "toUpperCase",
+      "toLowerCase",
+      "trim",
+      "trimStart",
+      "trimEnd",
+      "split",
+      "repeat",
+      "padStart",
+      "padEnd",
+      "concat",
+      "at",
+      "replace",
+      "replaceAll"
+    ]);
+    NUMBER_MEMBERS = /* @__PURE__ */ new Set(["toFixed", "toPrecision", "toString"]);
+    Scope = class {
+      parent;
+      isFunctionScope;
+      vars = /* @__PURE__ */ new Map();
+      consts = /* @__PURE__ */ new Set();
+      constructor(parent, isFunctionScope = false) {
+        this.parent = parent;
+        this.isFunctionScope = isFunctionScope;
+      }
+      declare(name, value, kind) {
+        if (kind === "var" && !this.isFunctionScope && this.parent) {
+          this.parent.declare(name, value, kind);
+          return;
+        }
+        this.vars.set(name, value);
+        if (kind === "const")
+          this.consts.add(name);
+      }
+      resolve(name) {
+        if (this.vars.has(name))
+          return this;
+        return this.parent?.resolve(name);
+      }
+      globalScope() {
+        return this.parent ? this.parent.globalScope() : this;
+      }
+      has(name) {
+        return this.resolve(name) !== void 0;
+      }
+      get(name) {
+        const s = this.resolve(name);
+        if (!s)
+          throw new Error(`${name} is not defined`);
+        return s.vars.get(name);
+      }
+      set(name, value) {
+        const s = this.resolve(name);
+        if (!s) {
+          this.globalScope().vars.set(name, value);
+          return;
+        }
+        if (s.consts.has(name))
+          throw new Error(`Assignment to constant variable "${name}"`);
+        s.vars.set(name, value);
+      }
+    };
+  }
+});
+
 // ../core/dist/tools/build-executor.js
-import * as vm from "vm";
 function createSeededRng(seed) {
   let s = seed;
   return () => {
@@ -1626,6 +2575,7 @@ function runBuildExecutor(code, palette, seed, options) {
     ]);
   }
   const rng = createSeededRng(seed ?? 42);
+  const safeMath = Object.freeze(Object.create(null, Object.getOwnPropertyDescriptors(Math)));
   const sandbox = {
     part: partFn,
     rpart: rpartFn,
@@ -1642,25 +2592,21 @@ function runBuildExecutor(code, palette, seed, options) {
     column: columnFn,
     pew: pewFn,
     fence: fenceFn,
-    Math,
+    Math: safeMath,
     GRID_SIZE: 1,
     rng,
-    console: { log: () => {
+    console: Object.freeze({ log: () => {
     }, warn: () => {
     }, error: () => {
-    } }
+    } })
   };
-  const context = vm.createContext(sandbox, {
-    codeGeneration: { strings: false, wasm: false }
-  });
-  const script = new vm.Script(code, { filename: "build-generator.js" });
   try {
-    script.runInContext(context, { timeout });
-  } catch (err) {
-    if (err.code === "ERR_SCRIPT_EXECUTION_TIMEOUT") {
+    runRestrictedScript(code, sandbox, { timeoutMs: timeout });
+  } catch (err2) {
+    if (err2 instanceof ScriptTimeoutError) {
       throw new Error(`Build code execution timed out after ${timeout}ms`);
     }
-    throw new Error(`Build code execution error: ${err.message}`);
+    throw new Error(`Build code execution error: ${err2?.message ?? String(err2)}`);
   }
   if (parts.length === 0) {
     throw new Error("Build code produced no parts. Make sure to call part(), wall(), floor(), etc.");
@@ -1672,6 +2618,7 @@ var DEFAULT_TIMEOUT, DEFAULT_MAX_PARTS, VALID_SHAPES;
 var init_build_executor = __esm({
   "../core/dist/tools/build-executor.js"() {
     "use strict";
+    init_build_interpreter();
     DEFAULT_TIMEOUT = 1e4;
     DEFAULT_MAX_PARTS = 1e4;
     VALID_SHAPES = /* @__PURE__ */ new Set(["Block", "Wedge", "Cylinder", "Ball", "CornerWedge"]);
@@ -1918,7 +2865,7 @@ var init_opencloud_client = __esm({
           if (result.error) {
             throw new Error(`Asset upload failed: ${result.error.message}`);
           }
-          await new Promise((resolve4) => setTimeout(resolve4, intervalMs));
+          await new Promise((resolve5) => setTimeout(resolve5, intervalMs));
         }
         throw new Error(`Asset upload timed out after ${maxAttempts * intervalMs / 1e3}s. Operation ID: ${operationId}`);
       }
@@ -2039,7 +2986,7 @@ function isRecord(value) {
   const record = value;
   return record.version === REGISTRY_VERSION && typeof record.recordId === "string" && typeof record.source === "string" && typeof record.exe === "string" && Array.isArray(record.args) && typeof record.launchedAt === "number" && typeof record.bootId === "string";
 }
-var REGISTRY_VERSION, LOCK_STALE_MS, LOCK_RETRY_MS, LOCK_TIMEOUT_MS, EVENT_RETENTION_DAYS, ManagedInstanceRegistry;
+var REGISTRY_VERSION, LOCK_STALE_MS, LOCK_RETRY_MS, LOCK_TIMEOUT_MS, EVENT_RETENTION_DAYS, TERMINAL_RECORD_RETENTION_MS, ManagedInstanceRegistry;
 var init_managed_instance_registry = __esm({
   "../core/dist/managed-instance-registry.js"() {
     "use strict";
@@ -2048,6 +2995,7 @@ var init_managed_instance_registry = __esm({
     LOCK_RETRY_MS = 25;
     LOCK_TIMEOUT_MS = 5e3;
     EVENT_RETENTION_DAYS = 2;
+    TERMINAL_RECORD_RETENTION_MS = 24 * 60 * 60 * 1e3;
     ManagedInstanceRegistry = class {
       dir;
       constructor(dir = defaultManagedInstanceRegistryDir()) {
@@ -2075,12 +3023,21 @@ var init_managed_instance_registry = __esm({
       findAnyByInstanceId(instanceId) {
         return this.withLock(() => this.readRecordsUnlocked().find((record) => record.instanceId === instanceId));
       }
+      findAnyByRecordId(recordId, options) {
+        return this.withLock(() => {
+          this.sweepUnlocked(options);
+          return this.readRecordsUnlocked().find((record) => record.recordId === recordId);
+        });
+      }
       listOpen(options) {
         return this.withLock(() => {
           this.sweepUnlocked(options);
           return this.readOpenRecordsUnlocked();
         });
       }
+      listOpenUnchecked() {
+        return this.withLock(() => this.readOpenRecordsUnlocked());
+      }
       markClosed(recordId, closedAt = Date.now()) {
         this.withLock(() => {
           const record = this.readRecordUnlocked(recordId);
@@ -2252,41 +3209,52 @@ var init_managed_instance_registry = __esm({
             }, now);
             continue;
           }
-          if (parsed.closedAt !== void 0) {
-            fs.rmSync(file, { force: true });
-            this.appendEventUnlocked({
-              event: "registry_pruned_closed_record",
-              recordId: parsed.recordId,
-              instanceId: parsed.instanceId,
-              source: parsed.source,
-              reason: "closed_at_present",
-              action: "deleted_record"
-            }, now);
+          const terminalAt = parsed.closedAt ?? parsed.exitedAt;
+          if (terminalAt !== void 0) {
+            if (now - terminalAt > TERMINAL_RECORD_RETENTION_MS) {
+              fs.rmSync(file, { force: true });
+              this.appendEventUnlocked({
+                event: "registry_pruned_terminal_record",
+                recordId: parsed.recordId,
+                instanceId: parsed.instanceId,
+                source: parsed.source,
+                reason: "terminal_retention_expired",
+                action: "deleted_record"
+              }, now);
+            }
             continue;
           }
           if (parsed.bootId !== options.currentBootId) {
             this.cleanupRecord(options, parsed);
-            fs.rmSync(file, { force: true });
+            parsed.state = parsed.state === "failed" ? "failed" : "exited";
+            parsed.exitedAt = now;
+            parsed.closedAt = now;
+            parsed.failureReason ??= "Studio process belongs to a previous host boot.";
+            this.writeRecordUnlocked(parsed);
             this.appendEventUnlocked({
-              event: "registry_pruned_previous_boot",
+              event: "registry_marked_previous_boot_exited",
               recordId: parsed.recordId,
               instanceId: parsed.instanceId,
               source: parsed.source,
               reason: "boot_id_changed",
-              action: "deleted_record_and_cleaned_baseplate"
+              action: "marked_exited_and_cleaned_baseplate"
             }, now);
             continue;
           }
           if (options.isProcessRunning && (parsed.nativeProcessId || parsed.spawnPid) && !options.isProcessRunning(parsed)) {
             this.cleanupRecord(options, parsed);
-            fs.rmSync(file, { force: true });
+            parsed.state = parsed.state === "failed" ? "failed" : "exited";
+            parsed.exitedAt = now;
+            parsed.closedAt = now;
+            parsed.failureReason ??= parsed.instanceId ? "Studio process exited." : "Studio process exited before the MCP plugin connected.";
+            this.writeRecordUnlocked(parsed);
             this.appendEventUnlocked({
-              event: "registry_pruned_stale_process",
+              event: "registry_marked_process_exited",
               recordId: parsed.recordId,
               instanceId: parsed.instanceId,
               source: parsed.source,
               reason: "pid_not_running",
-              action: "deleted_record_and_cleaned_baseplate"
+              action: "marked_exited_and_cleaned_baseplate"
             }, now);
           }
         }
@@ -2297,7 +3265,7 @@ var init_managed_instance_registry = __esm({
 
 // ../core/dist/studio-instance-manager.js
 import { execFileSync, spawn } from "child_process";
-import { copyFileSync, existsSync, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync, rmSync as rmSync2, statSync as statSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, realpathSync, rmSync as rmSync2, statSync as statSync2 } from "fs";
 import { randomUUID } from "crypto";
 import * as os2 from "os";
 import * as path2 from "path";
@@ -2312,14 +3280,14 @@ function isWsl() {
   if (process.platform !== "linux")
     return false;
   try {
-    return /microsoft|wsl/i.test(readFileSync2("/proc/version", "utf8"));
+    return /microsoft|wsl/i.test(readFileSync3("/proc/version", "utf8"));
   } catch {
     return false;
   }
 }
 function powershell(script) {
   return run("powershell.exe", ["-NoProfile", "-Command", script], {
-    cwd: isWsl() && existsSync("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
+    cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
   });
 }
 function windowsLocalAppData() {
@@ -2329,7 +3297,7 @@ function windowsLocalAppData() {
     return void 0;
   try {
     return run("cmd.exe", ["/c", "echo %LOCALAPPDATA%"], {
-      cwd: existsSync("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
+      cwd: existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
     });
   } catch {
     return void 0;
@@ -2341,10 +3309,67 @@ function toWslPath(windowsPath) {
   return run("wslpath", ["-u", windowsPath]);
 }
 function toStudioLaunchArg(arg) {
-  if (!isWsl() || !path2.isAbsolute(arg) || !existsSync(arg))
+  if (!isWsl() || !path2.isAbsolute(arg) || !existsSync2(arg))
     return arg;
   return run("wslpath", ["-w", arg]);
 }
+function powershellStringLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function quoteWindowsCommandLineArg(value) {
+  if (value.length > 0 && !/[\s"]/u.test(value))
+    return value;
+  let quoted = '"';
+  let backslashes = 0;
+  for (const char of value) {
+    if (char === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (char === '"') {
+      quoted += "\\".repeat(backslashes * 2 + 1) + '"';
+      backslashes = 0;
+      continue;
+    }
+    quoted += "\\".repeat(backslashes) + char;
+    backslashes = 0;
+  }
+  return `${quoted}${"\\".repeat(backslashes * 2)}"`;
+}
+function buildWindowsStudioStartScript(exe, args) {
+  const windowsExe = toStudioLaunchArg(exe);
+  const commandLine = args.map(quoteWindowsCommandLineArg).join(" ");
+  return [
+    "$psi = New-Object System.Diagnostics.ProcessStartInfo",
+    `$psi.FileName = ${powershellStringLiteral(windowsExe)}`,
+    `$psi.Arguments = ${powershellStringLiteral(commandLine)}`,
+    // With UseShellExecute=false, Studio inherits the synchronous
+    // powershell.exe invocation's stdout/stderr pipe handles under WSL. Those
+    // handles keep execFileSync waiting until Studio exits even though
+    // PowerShell already printed the PID. Shell execution prevents that
+    // inheritance while Process.Start still returns the native Studio PID.
+    "$psi.UseShellExecute = $true",
+    "$studio = [System.Diagnostics.Process]::Start($psi)",
+    'if ($null -eq $studio) { throw "Roblox Studio process did not start." }'
+  ].join("; ");
+}
+function spawnWindowsStudioFromWsl(exe, args) {
+  const script = buildWindowsStudioStartScript(exe, args);
+  const output = powershell(`${script}; [PSCustomObject]@{ pid = $studio.Id; started = $studio.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() } | ConvertTo-Json -Compress`);
+  const parsed = JSON.parse(output);
+  const nativePid = Number(parsed.pid);
+  const nativeStartedAt = typeof parsed.started === "string" && /^\d+$/u.test(parsed.started) ? parsed.started : void 0;
+  if (!Number.isSafeInteger(nativePid) || nativePid <= 0) {
+    throw new Error(`Could not determine the Windows Studio process id from: ${nativePid}`);
+  }
+  return {
+    pid: nativePid,
+    nativePid,
+    nativeStartedAt,
+    unref: () => {
+    }
+  };
+}
 function resolveEntrypointDir() {
   const entrypoint = process.argv[1];
   if (!entrypoint)
@@ -2367,13 +3392,44 @@ function resolveBaseplateTemplatePath() {
     path2.join(process.cwd(), "assets", BASEPLATE_TEMPLATE_NAME)
   ];
   for (const candidate of candidates) {
-    if (existsSync(candidate))
+    if (existsSync2(candidate))
       return candidate;
   }
   throw new Error(`Baseplate template not found. Expected ${BASEPLATE_TEMPLATE_NAME} in one of: ${candidates.join(", ")}`);
 }
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err2) {
+    return err2.code === "EPERM";
+  }
+}
+function sweepStaleBaseplateFiles() {
+  let entries;
+  try {
+    entries = readdirSync2(BASEPLATE_TEMP_DIR);
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - STALE_BASEPLATE_MAX_AGE_MS;
+  for (const entry of entries) {
+    const match = BASEPLATE_TEMP_SWEEP_NAME.exec(entry);
+    if (!match)
+      continue;
+    if (Number(match[1]) !== process.pid && isProcessAlive(Number(match[1])))
+      continue;
+    const file = path2.join(BASEPLATE_TEMP_DIR, entry);
+    try {
+      if (statSync2(file).mtimeMs < cutoff)
+        rmSync2(file, { force: true });
+    } catch {
+    }
+  }
+}
 function createBaseplatePlaceFile() {
-  mkdirSync2(BASEPLATE_TEMP_DIR, { recursive: true });
+  mkdirSync3(BASEPLATE_TEMP_DIR, { recursive: true });
+  sweepStaleBaseplateFiles();
   const file = path2.join(BASEPLATE_TEMP_DIR, `Baseplate-${process.pid}-${Date.now()}.rbxl`);
   copyFileSync(resolveBaseplateTemplatePath(), file);
   return file;
@@ -2387,8 +3443,12 @@ function cleanupManagedBaseplateFiles(record) {
     return;
   if (!isGeneratedBaseplatePlaceFile(record.localPlaceFile))
     return;
-  rmSync2(record.localPlaceFile, { force: true });
-  rmSync2(`${record.localPlaceFile}.lock`, { force: true });
+  for (const file of [record.localPlaceFile, `${record.localPlaceFile}.lock`]) {
+    try {
+      rmSync2(file, { force: true });
+    } catch {
+    }
+  }
 }
 function prepareStudioLaunchOptions(options) {
   if (options.source !== "baseplate" || options.localPlaceFile)
@@ -2409,10 +3469,10 @@ function resolveStudioExe() {
   }
   const localAppData = windowsLocalAppData();
   const root = localAppData ? path2.join(toWslPath(localAppData), "Roblox", "Versions") : path2.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
-  if (!existsSync(root)) {
+  if (!existsSync2(root)) {
     throw new Error(`Roblox Studio Versions folder not found: ${root}. Set ROBLOX_STUDIO_EXE.`);
   }
-  const candidates = readdirSync2(root).filter((name) => name.startsWith("version-")).map((name) => path2.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync(candidate)).sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs);
+  const candidates = readdirSync2(root).filter((name) => name.startsWith("version-")).map((name) => path2.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync2(candidate)).sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs);
   if (candidates.length === 0) {
     throw new Error(`RobloxStudioBeta.exe not found under ${root}. Set ROBLOX_STUDIO_EXE.`);
   }
@@ -2435,7 +3495,7 @@ function listStudioProcesses() {
     return [];
   let out = "";
   try {
-    out = powershell("Get-Process RobloxStudioBeta -ErrorAction SilentlyContinue | Select-Object Id,Name,Path,MainWindowTitle | ConvertTo-Json -Compress");
+    out = powershell("Get-Process RobloxStudioBeta -ErrorAction SilentlyContinue | ForEach-Object { [PSCustomObject]@{ Id = $_.Id; Name = $_.Name; Path = $_.Path; MainWindowTitle = $_.MainWindowTitle; StartTimeUtcFileTime = $_.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() } } | ConvertTo-Json -Compress");
   } catch {
     return [];
   }
@@ -2447,7 +3507,7 @@ function listStudioProcesses() {
 function currentBootId() {
   if (process.platform === "linux") {
     try {
-      return readFileSync2("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      return readFileSync3("/proc/sys/kernel/random/boot_id", "utf8").trim();
     } catch {
     }
   }
@@ -2499,12 +3559,12 @@ function buildStudioLaunchArgs(options) {
   }
 }
 function delay(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function basenameAny(filePath) {
   return path2.basename(filePath.replace(/\\/g, "/"));
 }
-var BASEPLATE_TEMP_DIR, BASEPLATE_TEMP_NAME, BASEPLATE_TEMPLATE_NAME, StudioInstanceManager;
+var BASEPLATE_TEMP_DIR, BASEPLATE_TEMP_NAME, BASEPLATE_TEMPLATE_NAME, STALE_BASEPLATE_MAX_AGE_MS, BASEPLATE_TEMP_SWEEP_NAME, StudioInstanceManager;
 var init_studio_instance_manager = __esm({
   "../core/dist/studio-instance-manager.js"() {
     "use strict";
@@ -2512,9 +3572,13 @@ var init_studio_instance_manager = __esm({
     BASEPLATE_TEMP_DIR = path2.join(os2.tmpdir(), "robloxstudio-mcp-baseplates");
     BASEPLATE_TEMP_NAME = /^Baseplate-\d+-\d+\.rbxl$/;
     BASEPLATE_TEMPLATE_NAME = "Baseplate.rbxl";
+    STALE_BASEPLATE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+    BASEPLATE_TEMP_SWEEP_NAME = /^Baseplate-(\d+)-\d+\.rbxl(\.lock)?$/;
     StudioInstanceManager = class {
       managedByInstanceId = /* @__PURE__ */ new Map();
       pending = /* @__PURE__ */ new Set();
+      monitors = /* @__PURE__ */ new Map();
+      connectionTimers = /* @__PURE__ */ new Map();
       registry;
       processAdapter;
       constructor(options = {}) {
@@ -2523,6 +3587,9 @@ var init_studio_instance_manager = __esm({
       }
       list() {
         this.sweepRegistry();
+        for (const record of [...this.managedByInstanceId.values(), ...this.pending]) {
+          this.refresh(record);
+        }
         const records = [...this.managedByInstanceId.values(), ...this.pending];
         for (const registryRecord of this.registry.listOpen(this.registrySweepOptions())) {
           const record = this.fromRegistryRecord(registryRecord);
@@ -2531,40 +3598,119 @@ var init_studio_instance_manager = __esm({
           }
           records.push(record);
         }
-        return records.filter((instance, index, all) => all.indexOf(instance) === index);
+        return records.filter((record) => record.closedAt === void 0).filter((instance, index, all) => all.indexOf(instance) === index);
       }
       get(instanceId) {
         this.sweepRegistry();
         const memoryRecord = this.managedByInstanceId.get(instanceId);
         if (memoryRecord)
-          return memoryRecord;
-        const registryRecord = this.registry.findOpenByInstanceId(instanceId, this.registrySweepOptions());
-        return registryRecord ? this.fromRegistryRecord(registryRecord) : void 0;
+          return this.refresh(memoryRecord);
+        const registryRecord = this.registry.findAnyByInstanceId(instanceId);
+        return registryRecord ? this.refresh(this.fromRegistryRecord(registryRecord)) : void 0;
+      }
+      getByLaunchId(launchId) {
+        this.sweepRegistry();
+        const memoryRecord = [...this.managedByInstanceId.values(), ...this.pending].find((record) => record.recordId === launchId);
+        if (memoryRecord)
+          return this.refresh(memoryRecord);
+        const registryRecord = this.registry.findAnyByRecordId(launchId, this.registrySweepOptions());
+        return registryRecord ? this.refresh(this.fromRegistryRecord(registryRecord)) : void 0;
+      }
+      pendingLaunches() {
+        const now = Date.now();
+        const records = [...this.pending];
+        for (const registryRecord of this.registry.listOpenUnchecked()) {
+          if (registryRecord.bootId !== this.getCurrentBootId())
+            continue;
+          if (records.some((record) => record.recordId === registryRecord.recordId))
+            continue;
+          records.push(this.fromRegistryRecord(registryRecord));
+        }
+        return records.filter((record) => record.instanceId === void 0).filter((record) => record.state === "launching").filter((record) => record.connectionDeadlineAt === void 0 || record.connectionDeadlineAt > now);
       }
       attachInstanceId(record, instanceId) {
+        this.refresh(record);
+        if (record.closedAt !== void 0 || record.state === "failed" || record.state === "exited")
+          return;
+        if (record.instanceId && record.instanceId !== instanceId)
+          return;
         record.instanceId = instanceId;
+        record.state = "connected";
+        record.connectedAt = record.connectedAt ?? Date.now();
+        this.clearConnectionTimer(record);
         this.pending.delete(record);
         this.managedByInstanceId.set(instanceId, record);
-        if (record.recordId) {
-          this.registry.attachInstanceId(record.recordId, instanceId);
+        this.persist(record);
+      }
+      markFailed(record, reason) {
+        this.refresh(record);
+        if (record.closedAt !== void 0 || record.state !== "launching")
+          return record;
+        record.state = "failed";
+        record.failedAt = Date.now();
+        record.failureReason = reason;
+        this.clearConnectionTimer(record);
+        this.persist(record);
+        return record;
+      }
+      refresh(record) {
+        if (record.closedAt !== void 0)
+          return record;
+        const processId = record.nativeProcessId ?? record.spawnPid;
+        const studioProcess = processId ? this.findProcessById(processId) : void 0;
+        if (processId && (!studioProcess || !this.verifyProcessForRecord(record, studioProcess))) {
+          return this.markProcessExited(record, void 0, studioProcess ? "Studio process identity changed; the retained PID was not reused." : record.instanceId ? "Studio process exited." : "Studio process exited before the MCP plugin connected.");
+        }
+        if (record.state === "launching" && record.connectionDeadlineAt !== void 0 && Date.now() >= record.connectionDeadlineAt) {
+          record.state = "failed";
+          record.failedAt = Date.now();
+          record.failureReason = "Studio launched, but the MCP plugin did not connect before timeout.";
+          this.clearConnectionTimer(record);
+          this.persist(record);
         }
+        return record;
       }
       async launch(options) {
         this.sweepRegistry();
         const preparedOptions = prepareStudioLaunchOptions(options);
+        const bootId = this.getCurrentBootId();
         const before = new Set(this.listStudioProcesses().map((proc2) => proc2.Id));
         const exe = this.processAdapter.resolveStudioExe?.() ?? resolveStudioExe();
         const args = buildStudioLaunchArgs(preparedOptions).map(toStudioLaunchArg);
         const spawnOptions = {
-          cwd: isWsl() && existsSync("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd(),
+          cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd(),
           detached: true,
           stdio: "ignore"
         };
-        const proc = this.processAdapter.spawnStudio ? this.processAdapter.spawnStudio(exe, args, spawnOptions) : spawn(exe, args, spawnOptions);
-        proc.unref();
+        let proc;
+        try {
+          if (this.processAdapter.spawnStudio) {
+            proc = this.processAdapter.spawnStudio(exe, args, spawnOptions);
+          } else if (isWsl()) {
+            proc = spawnWindowsStudioFromWsl(exe, args);
+          } else {
+            const child = spawn(exe, args, spawnOptions);
+            proc = {
+              pid: child.pid,
+              nativePid: child.pid,
+              unref: () => child.unref(),
+              onExit: (listener) => {
+                child.once("exit", listener);
+              },
+              onError: (listener) => {
+                child.once("error", listener);
+              }
+            };
+          }
+        } catch (error) {
+          cleanupManagedBaseplateFiles({ source: preparedOptions.source, localPlaceFile: preparedOptions.localPlaceFile });
+          throw error;
+        }
         const record = {
           recordId: randomUUID(),
           source: options.source,
+          nativeProcessId: proc.nativePid,
+          nativeProcessStartedAt: proc.nativeStartedAt,
           spawnPid: proc.pid,
           exe,
           args,
@@ -2573,29 +3719,74 @@ var init_studio_instance_manager = __esm({
           placeVersion: preparedOptions.placeVersion,
           localPlaceFile: preparedOptions.localPlaceFile,
           launchedAt: Date.now(),
+          connectionDeadlineAt: Date.now() + (options.connectionTimeoutMs ?? 12e4),
+          state: "launching",
           ownerPid: process.pid,
-          bootId: this.getCurrentBootId(),
+          bootId,
           deleteLocalPlaceFileOnClose: options.source === "baseplate"
         };
         this.pending.add(record);
-        this.registry.upsert(this.toRegistryRecord(record));
+        try {
+          this.persist(record);
+        } catch (error) {
+          this.pending.delete(record);
+          const processId = record.nativeProcessId ?? record.spawnPid;
+          let stopError;
+          if (processId) {
+            try {
+              this.closeProcess(processId);
+            } catch (caught) {
+              stopError = caught;
+            }
+          }
+          cleanupManagedBaseplateFiles(record);
+          const detail = error instanceof Error ? error.message : String(error);
+          const cleanupDetail = stopError ? ` The newly launched process could not be stopped: ${stopError instanceof Error ? stopError.message : String(stopError)}` : "";
+          throw new Error(`Studio launched, but its managed-instance record could not be persisted: ${detail}.${cleanupDetail}`);
+        }
+        proc.unref();
+        proc.onExit?.((code, signal) => {
+          this.markProcessExited(record, code ?? void 0, signal ? `Studio process exited from signal ${signal}.` : record.instanceId ? "Studio process exited." : "Studio process exited before the MCP plugin connected.");
+        });
+        proc.onError?.((error) => {
+          this.markFailed(record, `Studio process failed to start: ${error.message}`);
+        });
         const deadline = Date.now() + 5e3;
         while (Date.now() < deadline && record.nativeProcessId === void 0) {
           const created = this.listStudioProcesses().find((candidate) => !before.has(candidate.Id));
           if (created) {
             record.nativeProcessId = created.Id;
-            this.registry.upsert(this.toRegistryRecord(record));
+            record.nativeProcessStartedAt = created.StartTimeUtcFileTime;
+            this.persist(record);
             break;
           }
           await delay(250);
         }
         if (record.nativeProcessId === void 0 && process.platform !== "win32" && !isWsl()) {
           record.nativeProcessId = proc.pid;
-          this.registry.upsert(this.toRegistryRecord(record));
+          this.persist(record);
+        }
+        if (record.nativeProcessId !== void 0 && record.nativeProcessStartedAt === void 0) {
+          const nativeProcess = this.findProcessById(record.nativeProcessId);
+          if (nativeProcess?.StartTimeUtcFileTime !== void 0) {
+            record.nativeProcessStartedAt = nativeProcess.StartTimeUtcFileTime;
+            this.persist(record);
+          }
         }
+        this.startMonitor(record);
         return record;
       }
+      closeByLaunchId(launchId) {
+        const record = this.getByLaunchId(launchId);
+        if (!record)
+          return { status: "not_found", launchId };
+        if (record.closedAt !== void 0) {
+          return { status: "already_closed", launchId, instanceId: record.instanceId };
+        }
+        return this.close(record);
+      }
       closeByInstanceId(instanceId) {
+        this.sweepRegistry();
         const memoryRecord = this.managedByInstanceId.get(instanceId);
         if (memoryRecord)
           return this.close(memoryRecord);
@@ -2606,33 +3797,24 @@ var init_studio_instance_manager = __esm({
         }
         if (registryRecord.closedAt !== void 0) {
           this.cleanupManagedRecord(registryRecord);
-          this.registry.delete(registryRecord.recordId);
           this.registry.logEvent({
             event: "registry_close_already_stopped",
             recordId: registryRecord.recordId,
             instanceId: registryRecord.instanceId,
             source: registryRecord.source,
             reason: "closed_at_present",
-            action: "deleted_record_and_cleaned_baseplate"
-          });
-          return { status: "already_closed", instanceId };
-        }
-        if (registryRecord.bootId !== this.getCurrentBootId()) {
-          this.cleanupManagedRecord(registryRecord);
-          this.registry.delete(registryRecord.recordId);
-          this.registry.logEvent({
-            event: "registry_pruned_previous_boot",
-            recordId: registryRecord.recordId,
-            instanceId: registryRecord.instanceId,
-            source: registryRecord.source,
-            reason: "boot_id_changed",
-            action: "deleted_record_and_cleaned_baseplate"
+            action: "retained_terminal_record_and_cleaned_baseplate"
           });
-          return { status: "already_closed", instanceId };
+          return { status: "already_closed", launchId: registryRecord.recordId, instanceId };
         }
         return this.close(this.fromRegistryRecord(registryRecord));
       }
       close(record) {
+        this.stopMonitor(record);
+        this.refresh(record);
+        if (record.closedAt !== void 0) {
+          return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
+        }
         const processId = record.nativeProcessId ?? record.spawnPid;
         if (!processId) {
           throw new Error(`Cannot close ${record.instanceId ?? "Studio launch"} because its process id was not detected.`);
@@ -2640,8 +3822,7 @@ var init_studio_instance_manager = __esm({
         const studioProcess = this.findProcessById(processId);
         if (!studioProcess) {
           this.cleanupManagedRecord(record);
-          this.markClosedInMemory(record);
-          this.markClosedInRegistry(record);
+          this.markProcessExited(record, void 0, record.failureReason);
           this.registry.logEvent({
             event: "registry_close_already_stopped",
             recordId: record.recordId,
@@ -2650,7 +3831,7 @@ var init_studio_instance_manager = __esm({
             reason: "pid_not_running",
             action: "marked_closed_and_cleaned_baseplate"
           });
-          return { status: "already_closed", instanceId: record.instanceId };
+          return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
         }
         if (!this.verifyProcessForRecord(record, studioProcess)) {
           this.registry.logEvent({
@@ -2676,15 +3857,18 @@ var init_studio_instance_manager = __esm({
             action: "marked_closed_and_cleaned_baseplate"
           });
           this.cleanupManagedRecord(record);
-          this.markClosedInMemory(record);
-          this.markClosedInRegistry(record);
-          return { status: "already_closed", instanceId: record.instanceId };
-        }
-        record.closedAt = Date.now();
+          this.markProcessExited(record, void 0, record.failureReason);
+          return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
+        }
+        const closedAt = Date.now();
+        record.closedAt = closedAt;
+        record.exitedAt = record.exitedAt ?? closedAt;
+        if (record.state !== "failed")
+          record.state = "exited";
         this.cleanupManagedRecord(record);
         this.markClosedInMemory(record);
-        this.markClosedInRegistry(record);
-        return { status: "closed", instanceId: record.instanceId };
+        this.persist(record);
+        return { status: "closed", launchId: record.recordId, instanceId: record.instanceId };
       }
       closeConnectedInstance(instance) {
         const process2 = this.findProcessForConnectedInstance(instance);
@@ -2759,6 +3943,9 @@ var init_studio_instance_manager = __esm({
         const processName = `${studioProcess.Name ?? ""} ${studioProcess.Path ?? ""}`.toLowerCase();
         if (!processName.includes("robloxstudio"))
           return false;
+        if (record.nativeProcessStartedAt !== void 0 && studioProcess.StartTimeUtcFileTime !== record.nativeProcessStartedAt) {
+          return false;
+        }
         const processId = record.nativeProcessId ?? record.spawnPid;
         if (record.spawnPid && record.spawnPid === processId && studioProcess.Id === processId)
           return true;
@@ -2784,10 +3971,64 @@ var init_studio_instance_manager = __esm({
         if (record.instanceId)
           this.managedByInstanceId.delete(record.instanceId);
         this.pending.delete(record);
+        this.stopMonitor(record);
+      }
+      markProcessExited(record, exitCode, reason) {
+        if (record.closedAt !== void 0)
+          return record;
+        const exitedAt = Date.now();
+        record.exitedAt = exitedAt;
+        record.closedAt = exitedAt;
+        if (record.state !== "failed")
+          record.state = "exited";
+        if (exitCode !== void 0)
+          record.exitCode = exitCode;
+        if (reason)
+          record.failureReason = reason;
+        this.cleanupManagedRecord(record);
+        this.markClosedInMemory(record);
+        this.persist(record);
+        return record;
+      }
+      startMonitor(record) {
+        if (!record.recordId || record.closedAt !== void 0 || this.monitors.has(record.recordId))
+          return;
+        if (record.state === "launching" && record.connectionDeadlineAt !== void 0) {
+          const timeout = setTimeout(() => {
+            this.markFailed(record, "Studio launched, but the MCP plugin did not connect before timeout.");
+          }, Math.max(0, record.connectionDeadlineAt - Date.now()));
+          if (typeof timeout === "object" && "unref" in timeout)
+            timeout.unref();
+          this.connectionTimers.set(record.recordId, timeout);
+        }
+        const timer = setInterval(() => {
+          this.refresh(record);
+          if (record.closedAt !== void 0)
+            this.stopMonitor(record);
+        }, 5e3);
+        if (typeof timer === "object" && "unref" in timer)
+          timer.unref();
+        this.monitors.set(record.recordId, timer);
       }
-      markClosedInRegistry(record) {
-        if (record.recordId)
-          this.registry.markClosed(record.recordId, record.closedAt ?? Date.now());
+      stopMonitor(record) {
+        if (!record.recordId)
+          return;
+        const timer = this.monitors.get(record.recordId);
+        if (timer)
+          clearInterval(timer);
+        this.monitors.delete(record.recordId);
+        this.clearConnectionTimer(record);
+      }
+      clearConnectionTimer(record) {
+        if (!record.recordId)
+          return;
+        const timer = this.connectionTimers.get(record.recordId);
+        if (timer)
+          clearTimeout(timer);
+        this.connectionTimers.delete(record.recordId);
+      }
+      persist(record) {
+        this.registry.upsert(this.toRegistryRecord(record));
       }
       toRegistryRecord(record) {
         if (!record.recordId)
@@ -2800,6 +4041,7 @@ var init_studio_instance_manager = __esm({
           instanceId: record.instanceId,
           source: record.source,
           nativeProcessId: record.nativeProcessId,
+          nativeProcessStartedAt: record.nativeProcessStartedAt,
           spawnPid: record.spawnPid,
           exe: record.exe,
           args: record.args,
@@ -2809,18 +4051,26 @@ var init_studio_instance_manager = __esm({
           localPlaceFile: record.localPlaceFile,
           deleteLocalPlaceFileOnClose: record.deleteLocalPlaceFileOnClose,
           launchedAt: record.launchedAt,
-          attachedAt: record.instanceId ? Date.now() : void 0,
+          attachedAt: record.connectedAt,
+          connectionDeadlineAt: record.connectionDeadlineAt,
+          state: record.state,
+          failedAt: record.failedAt,
+          exitedAt: record.exitedAt,
+          exitCode: record.exitCode,
+          failureReason: record.failureReason,
           closedAt: record.closedAt,
           ownerPid: record.ownerPid,
           bootId: record.bootId
         };
       }
       fromRegistryRecord(record) {
+        const state = record.state ?? (record.closedAt !== void 0 ? "exited" : record.instanceId ? "connected" : "launching");
         return {
           recordId: record.recordId,
           source: record.source,
           instanceId: record.instanceId,
           nativeProcessId: record.nativeProcessId,
+          nativeProcessStartedAt: record.nativeProcessStartedAt,
           spawnPid: record.spawnPid,
           exe: record.exe,
           args: record.args,
@@ -2829,6 +4079,13 @@ var init_studio_instance_manager = __esm({
           placeVersion: record.placeVersion,
           localPlaceFile: record.localPlaceFile,
           launchedAt: record.launchedAt,
+          connectionDeadlineAt: record.connectionDeadlineAt ?? (state === "launching" ? record.launchedAt + 12e4 : void 0),
+          state,
+          connectedAt: record.attachedAt,
+          failedAt: record.failedAt,
+          exitedAt: record.exitedAt,
+          exitCode: record.exitCode,
+          failureReason: record.failureReason,
           closedAt: record.closedAt,
           ownerPid: record.ownerPid,
           bootId: record.bootId,
@@ -3014,6 +4271,982 @@ var init_image_decode = __esm({
   }
 });
 
+// ../../node_modules/fzstd/esm/index.mjs
+function decompress(dat, buf) {
+  var bufs = [], nb = +!buf;
+  var bt = 0, ol = 0;
+  for (; dat.length; ) {
+    var st = rzfh(dat, nb || buf);
+    if (typeof st == "object") {
+      if (nb) {
+        buf = null;
+        if (st.w.length == st.u) {
+          bufs.push(buf = st.w);
+          ol += st.u;
+        }
+      } else {
+        bufs.push(buf);
+        st.e = 0;
+      }
+      for (; !st.l; ) {
+        var blk = rzb(dat, st, buf);
+        if (!blk)
+          err(5);
+        if (buf)
+          st.e = st.y;
+        else {
+          bufs.push(blk);
+          ol += blk.length;
+          cpw(st.w, 0, blk.length);
+          st.w.set(blk, st.w.length - blk.length);
+        }
+      }
+      bt = st.b + st.c * 4;
+    } else
+      bt = st;
+    dat = dat.subarray(bt);
+  }
+  return cct(bufs, ol);
+}
+var ab, u8, u16, i16, i32, slc, fill, cpw, ec, err, rb, b4, rzfh, msb, rfse, rhu, dllt, dmlt, doct, b2bl, llb, llbl, mlb, mlbl, dhu, dhu4, rzb, cct;
+var init_esm = __esm({
+  "../../node_modules/fzstd/esm/index.mjs"() {
+    "use strict";
+    ab = ArrayBuffer;
+    u8 = Uint8Array;
+    u16 = Uint16Array;
+    i16 = Int16Array;
+    i32 = Int32Array;
+    slc = function(v, s, e) {
+      if (u8.prototype.slice)
+        return u8.prototype.slice.call(v, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      var n = new u8(e - s);
+      n.set(v.subarray(s, e));
+      return n;
+    };
+    fill = function(v, n, s, e) {
+      if (u8.prototype.fill)
+        return u8.prototype.fill.call(v, n, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      for (; s < e; ++s)
+        v[s] = n;
+      return v;
+    };
+    cpw = function(v, t, s, e) {
+      if (u8.prototype.copyWithin)
+        return u8.prototype.copyWithin.call(v, t, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      while (s < e) {
+        v[t++] = v[s++];
+      }
+    };
+    ec = [
+      "invalid zstd data",
+      "window size too large (>2046MB)",
+      "invalid block type",
+      "FSE accuracy too high",
+      "match distance too far back",
+      "unexpected EOF"
+    ];
+    err = function(ind, msg, nt) {
+      var e = new Error(msg || ec[ind]);
+      e.code = ind;
+      if (Error.captureStackTrace)
+        Error.captureStackTrace(e, err);
+      if (!nt)
+        throw e;
+      return e;
+    };
+    rb = function(d, b, n) {
+      var i = 0, o = 0;
+      for (; i < n; ++i)
+        o |= d[b++] << (i << 3);
+      return o;
+    };
+    b4 = function(d, b) {
+      return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+    };
+    rzfh = function(dat, w) {
+      var n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
+      if (n3 == 3126568 && dat[3] == 253) {
+        var flg = dat[4];
+        var ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = flg & 3, fcf = flg >> 6;
+        if (flg & 8)
+          err(0);
+        var bt = 6 - ss;
+        var db = df == 3 ? 4 : df;
+        var di = rb(dat, bt, db);
+        bt += db;
+        var fsb = fcf ? 1 << fcf : ss;
+        var fss = rb(dat, bt, fsb) + (fcf == 1 && 256);
+        var ws = fss;
+        if (!ss) {
+          var wb = 1 << 10 + (dat[5] >> 3);
+          ws = wb + (wb >> 3) * (dat[5] & 7);
+        }
+        if (ws > 2145386496)
+          err(1);
+        var buf = new u8((w == 1 ? fss || ws : w ? 0 : ws) + 12);
+        buf[0] = 1, buf[4] = 4, buf[8] = 8;
+        return {
+          b: bt + fsb,
+          y: 0,
+          l: 0,
+          d: di,
+          w: w && w != 1 ? w : buf.subarray(12),
+          e: ws,
+          o: new i32(buf.buffer, 0, 3),
+          u: fss,
+          c: cc,
+          m: Math.min(131072, ws)
+        };
+      } else if ((n3 >> 4 | dat[3] << 20) == 25481893) {
+        return b4(dat, 4) + 8;
+      }
+      err(0);
+    };
+    msb = function(val) {
+      var bits = 0;
+      for (; 1 << bits <= val; ++bits)
+        ;
+      return bits - 1;
+    };
+    rfse = function(dat, bt, mal) {
+      var tpos = (bt << 3) + 4;
+      var al = (dat[bt] & 15) + 5;
+      if (al > mal)
+        err(3);
+      var sz = 1 << al;
+      var probs = sz, sym = -1, re = -1, i = -1, ht = sz;
+      var buf = new ab(512 + (sz << 2));
+      var freq = new i16(buf, 0, 256);
+      var dstate = new u16(buf, 0, 256);
+      var nstate = new u16(buf, 512, sz);
+      var bb1 = 512 + (sz << 1);
+      var syms = new u8(buf, bb1, sz);
+      var nbits = new u8(buf, bb1 + sz);
+      while (sym < 255 && probs > 0) {
+        var bits = msb(probs + 1);
+        var cbt = tpos >> 3;
+        var msk = (1 << bits + 1) - 1;
+        var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (tpos & 7) & msk;
+        var msk1fb = (1 << bits) - 1;
+        var msv = msk - probs - 1;
+        var sval = val & msk1fb;
+        if (sval < msv)
+          tpos += bits, val = sval;
+        else {
+          tpos += bits + 1;
+          if (val > msk1fb)
+            val -= msv;
+        }
+        freq[++sym] = --val;
+        if (val == -1) {
+          probs += val;
+          syms[--ht] = sym;
+        } else
+          probs -= val;
+        if (!val) {
+          do {
+            var rbt = tpos >> 3;
+            re = (dat[rbt] | dat[rbt + 1] << 8) >> (tpos & 7) & 3;
+            tpos += 2;
+            sym += re;
+          } while (re == 3);
+        }
+      }
+      if (sym > 255 || probs)
+        err(0);
+      var sympos = 0;
+      var sstep = (sz >> 1) + (sz >> 3) + 3;
+      var smask = sz - 1;
+      for (var s = 0; s <= sym; ++s) {
+        var sf = freq[s];
+        if (sf < 1) {
+          dstate[s] = -sf;
+          continue;
+        }
+        for (i = 0; i < sf; ++i) {
+          syms[sympos] = s;
+          do {
+            sympos = sympos + sstep & smask;
+          } while (sympos >= ht);
+        }
+      }
+      if (sympos)
+        err(0);
+      for (i = 0; i < sz; ++i) {
+        var ns = dstate[syms[i]]++;
+        var nb = nbits[i] = al - msb(ns);
+        nstate[i] = (ns << nb) - sz;
+      }
+      return [tpos + 7 >> 3, {
+        b: al,
+        s: syms,
+        n: nbits,
+        t: nstate
+      }];
+    };
+    rhu = function(dat, bt) {
+      var i = 0, wc = -1;
+      var buf = new u8(292), hb = dat[bt];
+      var hw = buf.subarray(0, 256);
+      var rc = buf.subarray(256, 268);
+      var ri = new u16(buf.buffer, 268);
+      if (hb < 128) {
+        var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];
+        bt += hb;
+        var epos = ebt << 3;
+        var lb = dat[bt];
+        if (!lb)
+          err(0);
+        var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
+        var fpos = (++bt << 3) - 8 + msb(lb);
+        for (; ; ) {
+          fpos -= btr1;
+          if (fpos < epos)
+            break;
+          var cbt = fpos >> 3;
+          st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr1) - 1;
+          hw[++wc] = fdt.s[st1];
+          fpos -= btr2;
+          if (fpos < epos)
+            break;
+          cbt = fpos >> 3;
+          st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr2) - 1;
+          hw[++wc] = fdt.s[st2];
+          btr1 = fdt.n[st1];
+          st1 = fdt.t[st1];
+          btr2 = fdt.n[st2];
+          st2 = fdt.t[st2];
+        }
+        if (++wc > 255)
+          err(0);
+      } else {
+        wc = hb - 127;
+        for (; i < wc; i += 2) {
+          var byte = dat[++bt];
+          hw[i] = byte >> 4;
+          hw[i + 1] = byte & 15;
+        }
+        ++bt;
+      }
+      var wes = 0;
+      for (i = 0; i < wc; ++i) {
+        var wt = hw[i];
+        if (wt > 11)
+          err(0);
+        wes += wt && 1 << wt - 1;
+      }
+      var mb = msb(wes) + 1;
+      var ts = 1 << mb;
+      var rem = ts - wes;
+      if (rem & rem - 1)
+        err(0);
+      hw[wc++] = msb(rem) + 1;
+      for (i = 0; i < wc; ++i) {
+        var wt = hw[i];
+        ++rc[hw[i] = wt && mb + 1 - wt];
+      }
+      var hbuf = new u8(ts << 1);
+      var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
+      ri[mb] = 0;
+      for (i = mb; i > 0; --i) {
+        var pv = ri[i];
+        fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
+      }
+      if (ri[0] != ts)
+        err(0);
+      for (i = 0; i < wc; ++i) {
+        var bits = hw[i];
+        if (bits) {
+          var code = ri[bits];
+          fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
+        }
+      }
+      return [bt, {
+        n: nb,
+        b: mb,
+        s: syms
+      }];
+    };
+    dllt = rfse(/* @__PURE__ */ new u8([
+      81,
+      16,
+      99,
+      140,
+      49,
+      198,
+      24,
+      99,
+      12,
+      33,
+      196,
+      24,
+      99,
+      102,
+      102,
+      134,
+      70,
+      146,
+      4
+    ]), 0, 6)[1];
+    dmlt = rfse(/* @__PURE__ */ new u8([
+      33,
+      20,
+      196,
+      24,
+      99,
+      140,
+      33,
+      132,
+      16,
+      66,
+      8,
+      33,
+      132,
+      16,
+      66,
+      8,
+      33,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      36,
+      9
+    ]), 0, 6)[1];
+    doct = rfse(/* @__PURE__ */ new u8([
+      32,
+      132,
+      16,
+      66,
+      102,
+      70,
+      68,
+      68,
+      68,
+      68,
+      36,
+      73,
+      2
+    ]), 0, 5)[1];
+    b2bl = function(b, s) {
+      var len = b.length, bl = new i32(len);
+      for (var i = 0; i < len; ++i) {
+        bl[i] = s;
+        s += 1 << b[i];
+      }
+      return bl;
+    };
+    llb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+      0,
+      0,
+      0,
+      0,
+      16843009,
+      50528770,
+      134678020,
+      202050057,
+      269422093
+    ])).buffer, 0, 36);
+    llbl = /* @__PURE__ */ b2bl(llb, 0);
+    mlb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16843009,
+      50528770,
+      117769220,
+      185207048,
+      252579084,
+      16
+    ])).buffer, 0, 53);
+    mlbl = /* @__PURE__ */ b2bl(mlb, 3);
+    dhu = function(dat, out, hu) {
+      var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
+      if (!lb)
+        err(0);
+      var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
+      for (; pos > eb && i < ss; ) {
+        var cbt = pos >> 3;
+        var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (pos & 7);
+        st = (st << btr | val) & msk;
+        out[++i] = hu.s[st];
+        pos -= btr = hu.n[st];
+      }
+      if (pos != eb || i + 1 != ss)
+        err(0);
+    };
+    dhu4 = function(dat, out, hu) {
+      var bt = 6;
+      var ss = out.length, sz1 = ss + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
+      dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
+      dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
+      dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
+      dhu(dat.subarray(bt), out.subarray(sz3), hu);
+    };
+    rzb = function(dat, st, out) {
+      var _a;
+      var bt = st.b;
+      var b0 = dat[bt], btype = b0 >> 1 & 3;
+      st.l = b0 & 1;
+      var sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
+      var ebt = (bt += 3) + sz;
+      if (btype == 1) {
+        if (bt >= dat.length)
+          return;
+        st.b = bt + 1;
+        if (out) {
+          fill(out, dat[bt], st.y, st.y += sz);
+          return out;
+        }
+        return fill(new u8(sz), dat[bt]);
+      }
+      if (ebt > dat.length)
+        return;
+      if (btype == 0) {
+        st.b = ebt;
+        if (out) {
+          out.set(dat.subarray(bt, ebt), st.y);
+          st.y += sz;
+          return out;
+        }
+        return slc(dat, bt, ebt);
+      }
+      if (btype == 2) {
+        var b3 = dat[bt], lbt = b3 & 3, sf = b3 >> 2 & 3;
+        var lss = b3 >> 4, lcs = 0, s4 = 0;
+        if (lbt < 2) {
+          if (sf & 1)
+            lss |= dat[++bt] << 4 | (sf & 2 && dat[++bt] << 12);
+          else
+            lss = b3 >> 3;
+        } else {
+          s4 = sf;
+          if (sf < 2)
+            lss |= (dat[++bt] & 63) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
+          else if (sf == 2)
+            lss |= dat[++bt] << 4 | (dat[++bt] & 3) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
+          else
+            lss |= dat[++bt] << 4 | (dat[++bt] & 63) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
+        }
+        ++bt;
+        var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
+        var spl = buf.length - lss;
+        if (lbt == 0)
+          buf.set(dat.subarray(bt, bt += lss), spl);
+        else if (lbt == 1)
+          fill(buf, dat[bt++], spl);
+        else {
+          var hu = st.h;
+          if (lbt == 2) {
+            var hud = rhu(dat, bt);
+            lcs += bt - (bt = hud[0]);
+            st.h = hu = hud[1];
+          } else if (!hu)
+            err(0);
+          (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
+        }
+        var ns = dat[bt++];
+        if (ns) {
+          if (ns == 255)
+            ns = (dat[bt++] | dat[bt++] << 8) + 32512;
+          else if (ns > 127)
+            ns = ns - 128 << 8 | dat[bt++];
+          var scm = dat[bt++];
+          if (scm & 3)
+            err(0);
+          var dts = [dmlt, doct, dllt];
+          for (var i = 2; i > -1; --i) {
+            var md = scm >> (i << 1) + 2 & 3;
+            if (md == 1) {
+              var rbuf = new u8([0, 0, dat[bt++]]);
+              dts[i] = {
+                s: rbuf.subarray(2, 3),
+                n: rbuf.subarray(0, 1),
+                t: new u16(rbuf.buffer, 0, 1),
+                b: 0
+              };
+            } else if (md == 2) {
+              _a = rfse(dat, bt, 9 - (i & 1)), bt = _a[0], dts[i] = _a[1];
+            } else if (md == 3) {
+              if (!st.t)
+                err(0);
+              dts[i] = st.t[i];
+            }
+          }
+          var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];
+          var lb = dat[ebt - 1];
+          if (!lb)
+            err(0);
+          var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
+          var lst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << llt.b) - 1;
+          cbt = (spos -= oct.b) >> 3;
+          var ost = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << oct.b) - 1;
+          cbt = (spos -= mlt.b) >> 3;
+          var mst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mlt.b) - 1;
+          for (++ns; --ns; ) {
+            var llc = llt.s[lst];
+            var lbtr = llt.n[lst];
+            var mlc = mlt.s[mst];
+            var mbtr = mlt.n[mst];
+            var ofc = oct.s[ost];
+            var obtr = oct.n[ost];
+            cbt = (spos -= ofc) >> 3;
+            var ofp = 1 << ofc;
+            var off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (spos & 7) & ofp - 1);
+            cbt = (spos -= mlb[mlc]) >> 3;
+            var ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << mlb[mlc]) - 1);
+            cbt = (spos -= llb[llc]) >> 3;
+            var ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << llb[llc]) - 1);
+            cbt = (spos -= lbtr) >> 3;
+            lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << lbtr) - 1);
+            cbt = (spos -= mbtr) >> 3;
+            mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mbtr) - 1);
+            cbt = (spos -= obtr) >> 3;
+            ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << obtr) - 1);
+            if (off > 3) {
+              st.o[2] = st.o[1];
+              st.o[1] = st.o[0];
+              st.o[0] = off -= 3;
+            } else {
+              var idx = off - (ll != 0);
+              if (idx) {
+                off = idx == 3 ? st.o[0] - 1 : st.o[idx];
+                if (idx > 1)
+                  st.o[2] = st.o[1];
+                st.o[1] = st.o[0];
+                st.o[0] = off;
+              } else
+                off = st.o[0];
+            }
+            for (var i = 0; i < ll; ++i) {
+              buf[oubt + i] = buf[spl + i];
+            }
+            oubt += ll, spl += ll;
+            var stin = oubt - off;
+            if (stin < 0) {
+              var len = -stin;
+              var bs = st.e + stin;
+              if (len > ml)
+                len = ml;
+              for (var i = 0; i < len; ++i) {
+                buf[oubt + i] = st.w[bs + i];
+              }
+              oubt += len, ml -= len, stin = 0;
+            }
+            for (var i = 0; i < ml; ++i) {
+              buf[oubt + i] = buf[stin + i];
+            }
+            oubt += ml;
+          }
+          if (oubt != spl) {
+            while (spl < buf.length) {
+              buf[oubt++] = buf[spl++];
+            }
+          } else
+            oubt = buf.length;
+          if (out)
+            st.y += oubt;
+          else
+            buf = slc(buf, 0, oubt);
+        } else if (out) {
+          st.y += lss;
+          if (spl) {
+            for (var i = 0; i < lss; ++i) {
+              buf[i] = buf[spl + i];
+            }
+          }
+        } else if (spl)
+          buf = slc(buf, spl);
+        st.b = ebt;
+        return buf;
+      }
+      err(2);
+    };
+    cct = function(bufs, ol) {
+      if (bufs.length == 1)
+        return bufs[0];
+      var buf = new u8(ol);
+      for (var i = 0, b = 0; i < bufs.length; ++i) {
+        var chk = bufs[i];
+        buf.set(chk, b);
+        b += chk.length;
+      }
+      return buf;
+    };
+  }
+});
+
+// ../core/dist/studio-skills.js
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import * as path4 from "path";
+function decompressLz4Block(input, outputLength) {
+  const output = Buffer.allocUnsafe(outputLength);
+  let inputOffset = 0;
+  let outputOffset = 0;
+  const readExtendedLength = (initial) => {
+    let length = initial;
+    if (initial !== 15)
+      return length;
+    let next = 255;
+    while (next === 255) {
+      if (inputOffset >= input.length) {
+        throw new Error("Invalid LZ4 chunk: truncated extended length");
+      }
+      next = input[inputOffset++];
+      length += next;
+    }
+    return length;
+  };
+  while (inputOffset < input.length) {
+    const token = input[inputOffset++];
+    const literalLength = readExtendedLength(token >>> 4);
+    if (inputOffset + literalLength > input.length || outputOffset + literalLength > output.length) {
+      throw new Error("Invalid LZ4 chunk: literal exceeds chunk boundary");
+    }
+    input.copy(output, outputOffset, inputOffset, inputOffset + literalLength);
+    inputOffset += literalLength;
+    outputOffset += literalLength;
+    if (inputOffset === input.length)
+      break;
+    if (inputOffset + 2 > input.length) {
+      throw new Error("Invalid LZ4 chunk: missing match offset");
+    }
+    const matchOffset = input.readUInt16LE(inputOffset);
+    inputOffset += 2;
+    if (matchOffset === 0 || matchOffset > outputOffset) {
+      throw new Error("Invalid LZ4 chunk: invalid match offset");
+    }
+    const matchLength = readExtendedLength(token & 15) + 4;
+    if (outputOffset + matchLength > output.length) {
+      throw new Error("Invalid LZ4 chunk: match exceeds output boundary");
+    }
+    for (let index = 0; index < matchLength; index += 1) {
+      output[outputOffset] = output[outputOffset - matchOffset];
+      outputOffset += 1;
+    }
+  }
+  if (outputOffset !== output.length) {
+    throw new Error(`Invalid LZ4 chunk: produced ${outputOffset} bytes, expected ${output.length}`);
+  }
+  return output;
+}
+function decompressChunk(compressed, outputLength) {
+  if (compressed.subarray(0, ZSTD_MAGIC.length).equals(ZSTD_MAGIC)) {
+    const decompressed = Buffer.from(decompress(compressed));
+    if (decompressed.length !== outputLength) {
+      throw new Error(`Invalid Zstandard chunk: produced ${decompressed.length} bytes, expected ${outputLength}`);
+    }
+    return decompressed;
+  }
+  return decompressLz4Block(compressed, outputLength);
+}
+function readChunk(reader) {
+  if (reader.remaining < RBXM_CHUNK_HEADER_BYTES) {
+    throw new Error("Invalid Assistant.rbxm: truncated chunk header");
+  }
+  const type = reader.readBytes(4).toString("latin1");
+  const compressedLength = reader.readUint32();
+  const uncompressedLength = reader.readUint32();
+  reader.skip(4);
+  if (type === "END\0")
+    return { type };
+  if (compressedLength === 0) {
+    return { type, content: reader.readBytes(uncompressedLength) };
+  }
+  return {
+    type,
+    content: decompressChunk(reader.readBytes(compressedLength), uncompressedLength)
+  };
+}
+function parseFrontmatter(markdown) {
+  const match = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match)
+    return void 0;
+  const fields = /* @__PURE__ */ new Map();
+  for (const line of match[1].split(/\r?\n/)) {
+    const separator = line.indexOf(":");
+    if (separator <= 0)
+      continue;
+    const key = line.slice(0, separator).trim().toLowerCase();
+    let value = line.slice(separator + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      try {
+        value = JSON.parse(value);
+      } catch {
+      }
+    } else if (value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1).replace(/''/g, "'");
+    }
+    fields.set(key, value);
+  }
+  const name = fields.get("name")?.trim();
+  if (!name)
+    return void 0;
+  return { name, description: fields.get("description")?.trim() ?? "" };
+}
+function canonicalBuiltInSkillName(sourceName) {
+  return sourceName.toLowerCase().startsWith("rbx-") ? sourceName : `rbx-${sourceName}`;
+}
+function parseBuiltInStudioSkills(buffer) {
+  if (buffer.length < RBXM_HEADER_BYTES || !buffer.subarray(0, RBXM_MAGIC.length).equals(RBXM_MAGIC)) {
+    throw new Error("Invalid Assistant.rbxm: Roblox binary model header not found");
+  }
+  const reader = new ByteReader(buffer, "Assistant.rbxm");
+  reader.skip(RBXM_MAGIC.length);
+  reader.readUint16();
+  reader.readInt32();
+  reader.readInt32();
+  reader.skip(8);
+  const stringValueClasses = /* @__PURE__ */ new Map();
+  let foundEnd = false;
+  while (reader.remaining > 0) {
+    const chunk = readChunk(reader);
+    if (chunk.type === "END\0") {
+      foundEnd = true;
+      break;
+    }
+    if (!chunk.content)
+      continue;
+    const chunkReader = new ByteReader(chunk.content, `${chunk.type} chunk`);
+    if (chunk.type === "INST") {
+      const classId2 = chunkReader.readUint32();
+      const className = chunkReader.readString();
+      chunkReader.readUint8();
+      const count = chunkReader.readUint32();
+      chunkReader.skip(count * 4);
+      if (className === "StringValue")
+        stringValueClasses.set(classId2, { count });
+      continue;
+    }
+    if (chunk.type !== "PROP")
+      continue;
+    const classId = chunkReader.readUint32();
+    const propertyName = chunkReader.readString();
+    const propertyType = chunkReader.readUint8();
+    const classInfo = stringValueClasses.get(classId);
+    if (!classInfo || propertyType !== STRING_PROPERTY_TYPE)
+      continue;
+    if (propertyName !== "Name" && propertyName !== "Value")
+      continue;
+    const values = [];
+    for (let index = 0; index < classInfo.count; index += 1) {
+      values.push(chunkReader.readString());
+    }
+    if (propertyName === "Name")
+      classInfo.names = values;
+    else
+      classInfo.values = values;
+  }
+  if (!foundEnd)
+    throw new Error("Invalid Assistant.rbxm: END chunk not found");
+  const documents = [];
+  for (const classInfo of stringValueClasses.values()) {
+    if (!classInfo.names || !classInfo.values)
+      continue;
+    for (let index = 0; index < classInfo.count; index += 1) {
+      const document = classInfo.names[index];
+      if (document !== "SKILL" && document !== "SKILL-combined")
+        continue;
+      const content = classInfo.values[index];
+      const frontmatter = parseFrontmatter(content);
+      if (!frontmatter)
+        continue;
+      documents.push({
+        document,
+        sourceName: frontmatter.name,
+        description: frontmatter.description,
+        content
+      });
+    }
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    const key = document.sourceName.toLowerCase();
+    const group = grouped.get(key) ?? {};
+    if (document.document === "SKILL-combined")
+      group.combined = document;
+    else
+      group.base = document;
+    grouped.set(key, group);
+  }
+  return [...grouped.values()].map((group) => {
+    const selected = group.combined ?? group.base;
+    return {
+      name: canonicalBuiltInSkillName(selected.sourceName),
+      sourceName: selected.sourceName,
+      description: selected.description,
+      document: selected.document,
+      hasCombinedDocument: group.combined !== void 0,
+      content: selected.content,
+      contentLength: Buffer.byteLength(selected.content, "utf8"),
+      contentSha256: createHash2("sha256").update(selected.content).digest("hex")
+    };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+}
+function discoverNamedFile(root, fileName, depth = 0) {
+  if (depth > MAX_DISCOVERY_DEPTH || !existsSync4(root))
+    return [];
+  const matches = [];
+  let entries;
+  try {
+    entries = readdirSync3(root, { withFileTypes: true });
+  } catch {
+    return matches;
+  }
+  for (const entry of entries) {
+    const entryPath = path4.join(root, entry.name);
+    if (entry.isFile() && entry.name.toLowerCase() === fileName.toLowerCase()) {
+      matches.push(entryPath);
+    } else if (entry.isDirectory()) {
+      matches.push(...discoverNamedFile(entryPath, fileName, depth + 1));
+    }
+  }
+  return matches;
+}
+function resolveAssistantBundlePath(studioExe = resolveStudioExe()) {
+  const override = process.env.ROBLOX_STUDIO_ASSISTANT_BUNDLE;
+  if (override) {
+    if (!existsSync4(override)) {
+      throw new Error(`ROBLOX_STUDIO_ASSISTANT_BUNDLE does not exist: ${override}`);
+    }
+    return override;
+  }
+  const exeDirectory = path4.dirname(studioExe);
+  const roots = [
+    path4.join(exeDirectory, "BuiltInStandalonePlugins"),
+    path4.resolve(exeDirectory, "..", "Resources", "BuiltInStandalonePlugins"),
+    path4.resolve(exeDirectory, "..", "..", "OTAPlugins")
+  ];
+  const direct = path4.join(exeDirectory, "BuiltInStandalonePlugins", "Optimized_Embedded_Signature", "Assistant.rbxm");
+  const candidates = /* @__PURE__ */ new Set();
+  if (existsSync4(direct))
+    candidates.add(direct);
+  for (const root of roots) {
+    for (const candidate of discoverNamedFile(root, "Assistant.rbxm"))
+      candidates.add(candidate);
+  }
+  const newest = [...candidates].map((candidate) => ({ candidate, modifiedAt: statSync3(candidate).mtimeMs })).sort((left, right) => right.modifiedAt - left.modifiedAt)[0]?.candidate;
+  if (!newest) {
+    throw new Error(`Studio Assistant bundle not found for ${studioExe}. Set ROBLOX_STUDIO_ASSISTANT_BUNDLE to the installed Assistant.rbxm path.`);
+  }
+  return newest;
+}
+function loadBuiltInStudioSkills(bundlePath = resolveAssistantBundlePath()) {
+  const stats = statSync3(bundlePath);
+  if (cachedBundle?.path === bundlePath && cachedBundle.modifiedAt === stats.mtimeMs && cachedBundle.size === stats.size) {
+    return cachedBundle.value;
+  }
+  const buffer = readFileSync5(bundlePath);
+  const skills = parseBuiltInStudioSkills(buffer);
+  if (skills.length === 0) {
+    throw new Error(`No built-in skill documents found in ${bundlePath}`);
+  }
+  const studioVersion = bundlePath.split(path4.sep).find((segment) => /^version-[a-z0-9]+$/i.test(segment));
+  const value = {
+    bundlePath,
+    bundleModifiedAt: stats.mtime.toISOString(),
+    bundleSha256: createHash2("sha256").update(buffer).digest("hex"),
+    studioVersion,
+    skills
+  };
+  cachedBundle = { path: bundlePath, modifiedAt: stats.mtimeMs, size: stats.size, value };
+  return value;
+}
+function findBuiltInStudioSkill(bundle, requestedName) {
+  const wanted = requestedName.trim().toLowerCase();
+  return bundle.skills.find((skill) => skill.name.toLowerCase() === wanted || skill.sourceName.toLowerCase() === wanted);
+}
+var RBXM_MAGIC, RBXM_HEADER_BYTES, RBXM_CHUNK_HEADER_BYTES, ZSTD_MAGIC, STRING_PROPERTY_TYPE, MAX_DISCOVERY_DEPTH, ByteReader, cachedBundle;
+var init_studio_skills = __esm({
+  "../core/dist/studio-skills.js"() {
+    "use strict";
+    init_esm();
+    init_studio_instance_manager();
+    RBXM_MAGIC = Buffer.from("<roblox!\x89\xFF\r\n\n", "latin1");
+    RBXM_HEADER_BYTES = 32;
+    RBXM_CHUNK_HEADER_BYTES = 16;
+    ZSTD_MAGIC = Buffer.from([40, 181, 47, 253]);
+    STRING_PROPERTY_TYPE = 1;
+    MAX_DISCOVERY_DEPTH = 6;
+    ByteReader = class {
+      bytes;
+      label;
+      offset = 0;
+      constructor(bytes, label) {
+        this.bytes = bytes;
+        this.label = label;
+      }
+      get remaining() {
+        return this.bytes.length - this.offset;
+      }
+      requireBytes(length) {
+        if (!Number.isSafeInteger(length) || length < 0 || this.remaining < length) {
+          throw new Error(`Invalid ${this.label}: requested ${length} bytes with ${this.remaining} remaining`);
+        }
+      }
+      readUint8() {
+        this.requireBytes(1);
+        return this.bytes[this.offset++];
+      }
+      readUint16() {
+        this.requireBytes(2);
+        const value = this.bytes.readUInt16LE(this.offset);
+        this.offset += 2;
+        return value;
+      }
+      readUint32() {
+        this.requireBytes(4);
+        const value = this.bytes.readUInt32LE(this.offset);
+        this.offset += 4;
+        return value;
+      }
+      readInt32() {
+        this.requireBytes(4);
+        const value = this.bytes.readInt32LE(this.offset);
+        this.offset += 4;
+        return value;
+      }
+      readBytes(length) {
+        this.requireBytes(length);
+        const value = this.bytes.subarray(this.offset, this.offset + length);
+        this.offset += length;
+        return value;
+      }
+      skip(length) {
+        this.requireBytes(length);
+        this.offset += length;
+      }
+      readString() {
+        const length = this.readUint32();
+        return this.readBytes(length).toString("utf8");
+      }
+    };
+  }
+});
+
 // ../core/dist/jpeg-encoder.js
 function rgbaToJpeg(rgba, width, height, quality = 80) {
   if (width <= 0 || height <= 0)
@@ -4033,7 +6266,7 @@ var init_png_encoder = __esm({
 // ../core/dist/tools/index.js
 import * as fs3 from "fs";
 import * as os3 from "os";
-import * as path4 from "path";
+import * as path5 from "path";
 function multiplayerStopDisabledBody() {
   return {
     success: false,
@@ -4058,7 +6291,7 @@ function encodeImageFromRgbaResponse(response, format, quality) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -4120,7 +6353,7 @@ function loadMicroProfilerBaseline(source, sourcePath) {
     if (typeof sourcePath !== "string" || sourcePath === "") {
       throw new Error("baseline_path must be a non-empty string when provided");
     }
-    const resolved = path4.resolve(sourcePath);
+    const resolved = path5.resolve(sourcePath);
     const parsed = JSON.parse(fs3.readFileSync(resolved, "utf8"));
     const record = asRecord(parsed);
     if (!record)
@@ -4581,6 +6814,7 @@ var init_tools = __esm({
     init_studio_instance_manager();
     init_image_decode();
     init_roblox_docs();
+    init_studio_skills();
     init_jpeg_encoder();
     init_png_encoder();
     MAX_INLINE_IMAGE_BYTES = 6e6;
@@ -4648,10 +6882,52 @@ var init_tools = __esm({
         this.openCloudClient = new OpenCloudClient();
         this.cookieClient = new RobloxCookieClient();
         this.instanceManager = new StudioInstanceManager();
+        this.bridge.onInstanceRegistered((instance) => this._associateManagedEditConnection(instance));
       }
       _textResult(body) {
         return { content: [{ type: "text", text: JSON.stringify(body) }] };
       }
+      async getRobloxSkills(action, name) {
+        if (action !== "list" && action !== "get") {
+          throw new Error('get_roblox_skills action must be "list" or "get"');
+        }
+        const bundle = loadBuiltInStudioSkills();
+        const bundleMetadata = {
+          source: "installed-studio-assistant",
+          studioVersion: bundle.studioVersion,
+          bundlePath: bundle.bundlePath,
+          bundleModifiedAt: bundle.bundleModifiedAt,
+          bundleSha256: bundle.bundleSha256
+        };
+        if (action === "list") {
+          return this._textResult({
+            action,
+            ...bundleMetadata,
+            count: bundle.skills.length,
+            skills: bundle.skills.map((skill2) => ({
+              name: skill2.name,
+              sourceName: skill2.sourceName,
+              description: skill2.description,
+              document: skill2.document,
+              hasCombinedDocument: skill2.hasCombinedDocument,
+              contentLength: skill2.contentLength,
+              contentSha256: skill2.contentSha256
+            }))
+          });
+        }
+        if (!name || typeof name !== "string" || !name.trim()) {
+          throw new Error('get_roblox_skills action="get" requires a skill name from action="list"');
+        }
+        const skill = findBuiltInStudioSkill(bundle, name);
+        if (!skill) {
+          throw new Error(`Built-in Studio skill "${name}" was not found. Available skills: ` + bundle.skills.map((candidate) => candidate.name).join(", "));
+        }
+        return this._textResult({
+          action,
+          ...bundleMetadata,
+          skill
+        });
+      }
       async getRobloxDocs(name, docType, section) {
         if (!name || typeof name !== "string") {
           throw new Error('get_roblox_docs requires a name (e.g. "ProximityPrompt")');
@@ -5004,8 +7280,8 @@ var init_tools = __esm({
           timedOut: true
         };
       }
-      async getFileTree(path5 = "", instance_id) {
-        const response = await this._callSingle("/api/file-tree", { path: path5 }, void 0, instance_id);
+      async getFileTree(path6 = "", instance_id) {
+        const response = await this._callSingle("/api/file-tree", { path: path6 }, void 0, instance_id);
         return {
           content: [
             {
@@ -5122,9 +7398,9 @@ var init_tools = __esm({
           ]
         };
       }
-      async getProjectStructure(path5, maxDepth, scriptsOnly, instance_id) {
+      async getProjectStructure(path6, maxDepth, scriptsOnly, instance_id) {
         const response = await this._callSingle("/api/project-structure", {
-          path: path5,
+          path: path6,
           maxDepth,
           scriptsOnly
         }, void 0, instance_id);
@@ -6048,8 +8324,8 @@ ${code}`
           const rawJson = mutable.raw_json;
           if (typeof rawJson === "string") {
             if (typeof outputPath === "string" && outputPath !== "") {
-              const resolvedOutputPath = path4.resolve(outputPath);
-              fs3.mkdirSync(path4.dirname(resolvedOutputPath), { recursive: true });
+              const resolvedOutputPath = path5.resolve(outputPath);
+              fs3.mkdirSync(path5.dirname(resolvedOutputPath), { recursive: true });
               fs3.writeFileSync(resolvedOutputPath, rawJson, "utf8");
               mutable.output_path = resolvedOutputPath;
             }
@@ -6111,8 +8387,8 @@ ${code}`
           const rawSnapshotBase64 = mutable.raw_snapshot_base64;
           if (typeof rawSnapshotBase64 === "string") {
             if (typeof outputPath === "string" && outputPath !== "") {
-              const resolvedOutputPath = path4.resolve(outputPath);
-              fs3.mkdirSync(path4.dirname(resolvedOutputPath), { recursive: true });
+              const resolvedOutputPath = path5.resolve(outputPath);
+              fs3.mkdirSync(path5.dirname(resolvedOutputPath), { recursive: true });
               fs3.writeFileSync(resolvedOutputPath, Buffer.from(rawSnapshotBase64, "base64"));
               mutable.output_path = resolvedOutputPath;
             }
@@ -6127,8 +8403,8 @@ ${code}`
             });
           }
           if (typeof summaryOutputPath === "string" && summaryOutputPath !== "") {
-            const resolvedSummaryPath = path4.resolve(summaryOutputPath);
-            fs3.mkdirSync(path4.dirname(resolvedSummaryPath), { recursive: true });
+            const resolvedSummaryPath = path5.resolve(summaryOutputPath);
+            fs3.mkdirSync(path5.dirname(resolvedSummaryPath), { recursive: true });
             fs3.writeFileSync(resolvedSummaryPath, JSON.stringify(mutable, null, 2), "utf8");
             mutable.summary_output_path = resolvedSummaryPath;
           }
@@ -6196,11 +8472,18 @@ ${code}`
           return record.placeId !== void 0 && instance.placeId === record.placeId;
         }
         if ((record.source === "baseplate" || record.source === "local_file") && record.localPlaceFile) {
-          const expectedName = path4.basename(record.localPlaceFile);
+          const expectedName = path5.basename(record.localPlaceFile);
           return instance.placeName === expectedName || instance.dataModelName === expectedName;
         }
         return true;
       }
+      _associateManagedEditConnection(instance) {
+        if (instance.role !== "edit")
+          return;
+        const candidate = this.instanceManager.pendingLaunches().filter((record) => instance.connectedAt >= record.launchedAt - 1e3).filter((record) => this._matchesManagedLaunch(record, instance)).sort((a, b) => a.launchedAt - b.launchedAt)[0];
+        if (candidate)
+          this.instanceManager.attachInstanceId(candidate, instance.instanceId);
+      }
       async _deriveUniverseId(placeId) {
         const response = await fetch(`https://apis.roblox.com/universes/v1/places/${placeId}/universe`);
         if (!response.ok) {
@@ -6216,6 +8499,10 @@ ${code}`
       async _waitForManagedEditConnection(record, beforeKeys, timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
+          this.instanceManager.refresh(record);
+          if (record.state === "failed" || record.state === "exited" || record.closedAt !== void 0) {
+            return void 0;
+          }
           const candidates = this.bridge.getPublicInstances().filter((instance) => instance.role === "edit").filter((instance) => !beforeKeys.has(this._publicInstanceKey(instance))).filter((instance) => instance.connectedAt >= record.launchedAt - 1e3).filter((instance) => this._matchesManagedLaunch(record, instance)).sort((a, b) => b.connectedAt - a.connectedAt);
           if (candidates[0])
             return candidates[0];
@@ -6224,12 +8511,25 @@ ${code}`
         return void 0;
       }
       _managedStatus(record) {
+        this.instanceManager.refresh(record);
         const connected = record.instanceId ? this.bridge.getPublicInstances().filter((instance) => instance.instanceId === record.instanceId) : [];
         return {
+          launch_id: record.recordId,
           instance_id: record.instanceId,
+          managed: true,
+          state: record.state,
+          pid: record.nativeProcessId ?? record.spawnPid,
+          process_running: record.closedAt === void 0 && record.exitedAt === void 0,
           source: record.source,
+          local_place_file: record.localPlaceFile,
           place_id: record.placeId,
           place_version: record.placeVersion,
+          launched_at: new Date(record.launchedAt).toISOString(),
+          connected_at: record.connectedAt ? new Date(record.connectedAt).toISOString() : void 0,
+          failed_at: record.failedAt ? new Date(record.failedAt).toISOString() : void 0,
+          exited_at: record.exitedAt ? new Date(record.exitedAt).toISOString() : void 0,
+          exit_code: record.exitCode,
+          failure_reason: record.failureReason,
           connected: connected.length > 0,
           roles: connected.map((instance) => instance.role).sort()
         };
@@ -6241,6 +8541,10 @@ ${code}`
       async manageInstance(request) {
         const action = request.action;
         const instance_id = typeof request.instance_id === "string" ? request.instance_id : void 0;
+        const launch_id = typeof request.launch_id === "string" ? request.launch_id : void 0;
+        if (instance_id && launch_id) {
+          throw new Error("manage_instance accepts only one of instance_id or launch_id.");
+        }
         if (action !== "launch" && action !== "close" && action !== "status" && action !== "list_place_versions") {
           throw new Error("manage_instance requires action=launch|close|status|list_place_versions");
         }
@@ -6268,18 +8572,26 @@ ${code}`
           return this._textResult(body);
         }
         if (action === "status") {
+          if (launch_id) {
+            const record2 = this.instanceManager.getByLaunchId(launch_id);
+            if (!record2)
+              return this._textResult({ error: "Launch is not managed.", launch_id });
+            return this._textResult(this._managedStatus(record2));
+          }
           if (instance_id) {
             const record2 = this.instanceManager.get(instance_id);
             const connected2 = this.bridge.getPublicInstances().filter((instance) => instance.instanceId === instance_id);
             if (!record2 && connected2.length === 0) {
               return this._textResult({ error: "Instance is not connected or managed.", instance_id });
             }
+            if (record2)
+              return this._textResult(this._managedStatus(record2));
             return this._textResult({
               instance_id,
-              managed: !!record2,
-              source: record2?.source,
-              place_id: record2?.placeId ?? connected2[0]?.placeId,
-              place_version: record2?.placeVersion,
+              managed: false,
+              state: "connected",
+              place_id: connected2[0]?.placeId,
+              connected: true,
               roles: connected2.map((instance) => instance.role).sort()
             });
           }
@@ -6295,14 +8607,32 @@ ${code}`
         }
         if (action === "close") {
           let record2;
+          if (launch_id) {
+            record2 = this.instanceManager.getByLaunchId(launch_id);
+            if (!record2)
+              return this._textResult({ error: "Launch is not managed.", launch_id });
+            const connectedInstanceId = record2.instanceId;
+            const closeResult2 = record2.closedAt === void 0 ? this.instanceManager.close(record2) : { status: "already_closed" };
+            if (connectedInstanceId) {
+              await this.bridge.unregisterInstanceIdEverywhere(connectedInstanceId);
+              await sleep(500);
+              await this.bridge.unregisterInstanceIdEverywhere(connectedInstanceId);
+            }
+            return this._textResult({
+              ...this._managedStatus(record2),
+              message: closeResult2.status === "already_closed" ? "Studio instance was already closed." : "Studio instance closed."
+            });
+          }
           if (instance_id) {
+            const recordBeforeClose = this.instanceManager.get(instance_id);
             const managedClose = this.instanceManager.closeByInstanceId(instance_id);
             if (managedClose.status !== "not_found") {
               await this.bridge.unregisterInstanceIdEverywhere(instance_id);
               await sleep(500);
               await this.bridge.unregisterInstanceIdEverywhere(instance_id);
+              const closedRecord = recordBeforeClose ?? (managedClose.launchId ? this.instanceManager.getByLaunchId(managedClose.launchId) : void 0);
               return this._textResult({
-                instance_id,
+                ...closedRecord ? this._managedStatus(closedRecord) : { instance_id },
                 message: managedClose.status === "already_closed" ? "Studio instance was already closed." : "Studio instance closed."
               });
             }
@@ -6349,7 +8679,7 @@ ${code}`
             await this.bridge.unregisterInstanceIdEverywhere(record2.instanceId);
           }
           return this._textResult({
-            instance_id: record2.instanceId,
+            ...this._managedStatus(record2),
             message: closeResult.status === "already_closed" ? "Studio instance was already closed." : "Studio instance closed."
           });
         }
@@ -6376,24 +8706,34 @@ ${code}`
           localPlaceFile,
           placeId,
           universeId,
-          placeVersion
+          placeVersion,
+          connectionTimeoutMs: timeoutMs
         });
         if (!waitForConnection) {
-          return this._textResult({ message: "Studio launch requested." });
+          return this._textResult({
+            ...this._managedStatus(record),
+            message: "Studio launch requested."
+          });
         }
         const connected = await this._waitForManagedEditConnection(record, beforeKeys, timeoutMs);
         if (!connected) {
-          try {
-            this.instanceManager.close(record);
-          } catch {
+          if (record.state === "launching") {
+            this.instanceManager.markFailed(record, "Studio launched, but the MCP plugin did not connect before timeout.");
+          }
+          if (record.closedAt === void 0) {
+            try {
+              this.instanceManager.close(record);
+            } catch {
+            }
           }
           return this._textResult({
-            error: "Studio launched, but the MCP plugin did not connect before timeout."
+            ...this._managedStatus(record),
+            error: record.failureReason ?? "Studio launched, but the MCP plugin did not connect before timeout."
           });
         }
         this.instanceManager.attachInstanceId(record, connected.instanceId);
         return this._textResult({
-          instance_id: connected.instanceId,
+          ...this._managedStatus(record),
           message: launchSource === "place_revision" ? `Studio opened place revision ${placeVersion}.` : "Studio opened."
         });
       }
@@ -6576,16 +8916,16 @@ ${code}`
           try {
             editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
             body.edit = editState;
-          } catch (err) {
-            body.edit = { error: err instanceof Error ? err.message : String(err) };
+          } catch (err2) {
+            body.edit = { error: err2 instanceof Error ? err2.message : String(err2) };
           }
         }
         if (server) {
           try {
             serverState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "server");
             body.server = serverState;
-          } catch (err) {
-            body.server = { error: err instanceof Error ? err.message : String(err) };
+          } catch (err2) {
+            body.server = { error: err2 instanceof Error ? err2.message : String(err2) };
           }
         }
         const session = editState?.session;
@@ -6911,14 +9251,14 @@ ${code}`
         };
       }
       static findProjectRoot(startDir) {
-        let dir = path4.resolve(startDir);
+        let dir = path5.resolve(startDir);
         let previous = "";
         while (dir !== previous) {
-          if (fs3.existsSync(path4.join(dir, ".git")) || fs3.existsSync(path4.join(dir, "package.json"))) {
+          if (fs3.existsSync(path5.join(dir, ".git")) || fs3.existsSync(path5.join(dir, "package.json"))) {
             return dir;
           }
           previous = dir;
-          dir = path4.dirname(dir);
+          dir = path5.dirname(dir);
         }
         return null;
       }
@@ -6932,7 +9272,7 @@ ${code}`
         }
       }
       static ensureWritableDirectory(candidate, label) {
-        const resolved = path4.resolve(candidate);
+        const resolved = path5.resolve(candidate);
         try {
           fs3.mkdirSync(resolved, { recursive: true });
         } catch (error) {
@@ -6953,11 +9293,11 @@ ${code}`
         if (_RobloxStudioTools._cachedLibraryPath)
           return _RobloxStudioTools._cachedLibraryPath;
         const overridePath = process.env.ROBLOXSTUDIO_MCP_BUILD_LIBRARY || process.env.BUILD_LIBRARY_PATH;
-        const cwd = path4.resolve(process.cwd());
+        const cwd = path5.resolve(process.cwd());
         const projectRoot = _RobloxStudioTools.findProjectRoot(cwd);
-        const homeLibraryPath = path4.join(os3.homedir(), ".robloxstudio-mcp", "build-library");
-        const projectLibraryPath = projectRoot ? path4.join(projectRoot, "build-library") : null;
-        const cwdLibraryPath = path4.join(cwd, "build-library");
+        const homeLibraryPath = path5.join(os3.homedir(), ".robloxstudio-mcp", "build-library");
+        const projectLibraryPath = projectRoot ? path5.join(projectRoot, "build-library") : null;
+        const cwdLibraryPath = path5.join(cwd, "build-library");
         let result;
         if (overridePath) {
           result = _RobloxStudioTools.ensureWritableDirectory(overridePath, "override");
@@ -6971,12 +9311,12 @@ ${code}`
             }
           })());
           if (existing) {
-            result = path4.resolve(existing);
+            result = path5.resolve(existing);
           } else if (projectLibraryPath) {
             try {
               result = _RobloxStudioTools.ensureWritableDirectory(projectLibraryPath, "project-root");
-            } catch (err) {
-              console.error(`Warning: could not create build-library at project root (${projectLibraryPath}): ${err.message}. Falling back to home directory.`);
+            } catch (err2) {
+              console.error(`Warning: could not create build-library at project root (${projectLibraryPath}): ${err2.message}. Falling back to home directory.`);
               result = _RobloxStudioTools.ensureWritableDirectory(homeLibraryPath, "home");
             }
           } else {
@@ -6998,8 +9338,8 @@ ${code}`
         if (response && response.success && response.buildData) {
           const buildData = response.buildData;
           const buildId = buildData.id || `${style}/exported`;
-          const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${buildId}.json`);
-          const dirPath = path4.dirname(filePath);
+          const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${buildId}.json`);
+          const dirPath = path5.dirname(filePath);
           if (!fs3.existsSync(dirPath)) {
             fs3.mkdirSync(dirPath, { recursive: true });
           }
@@ -7100,8 +9440,8 @@ ${code}`
         const normalizedParts = this.normalizeBuildParts(parts, new Set(Object.keys(normalizedPalette)));
         const computedBounds = bounds || this.computeBounds(normalizedParts);
         const buildData = { id, style, bounds: computedBounds, palette: normalizedPalette, parts: normalizedParts };
-        const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
-        const dirPath = path4.dirname(filePath);
+        const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
+        const dirPath = path5.dirname(filePath);
         if (!fs3.existsSync(dirPath)) {
           fs3.mkdirSync(dirPath, { recursive: true });
         }
@@ -7159,8 +9499,8 @@ ${code}`
         };
         if (seed !== void 0)
           buildData.generatorSeed = seed;
-        const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
-        const dirPath = path4.dirname(filePath);
+        const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
+        const dirPath = path5.dirname(filePath);
         if (!fs3.existsSync(dirPath)) {
           fs3.mkdirSync(dirPath, { recursive: true });
         }
@@ -7188,13 +9528,13 @@ ${code}`
         }
         let resolved;
         if (typeof buildData === "string") {
-          const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${buildData}.json`);
+          const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${buildData}.json`);
           if (!fs3.existsSync(filePath)) {
             throw new Error(`Build not found in library: ${buildData}`);
           }
           resolved = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
         } else if (buildData.id && !buildData.parts) {
-          const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${buildData.id}.json`);
+          const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${buildData.id}.json`);
           if (!fs3.existsSync(filePath)) {
             throw new Error(`Build not found in library: ${buildData.id}`);
           }
@@ -7221,13 +9561,13 @@ ${code}`
         const styles = style ? [style] : ["medieval", "modern", "nature", "scifi", "misc"];
         const builds = [];
         for (const s of styles) {
-          const dirPath = path4.join(libraryPath, s);
+          const dirPath = path5.join(libraryPath, s);
           if (!fs3.existsSync(dirPath))
             continue;
           const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".json"));
           for (const file of files) {
             try {
-              const content = fs3.readFileSync(path4.join(dirPath, file), "utf-8");
+              const content = fs3.readFileSync(path5.join(dirPath, file), "utf-8");
               const data = JSON.parse(content);
               builds.push({
                 id: data.id || `${s}/${file.replace(".json", "")}`,
@@ -7266,7 +9606,7 @@ ${code}`
         if (!id) {
           throw new Error("Build ID is required for get_build");
         }
-        const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
+        const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
         if (!fs3.existsSync(filePath)) {
           throw new Error(`Build not found in library: ${id}`);
         }
@@ -7353,7 +9693,7 @@ ${code}`
           if (!buildId) {
             throw new Error(`Invalid ${validatedKeyPath}: model key "${modelKey}" is not defined in sceneData.models`);
           }
-          const filePath = path4.join(libraryPath, `${buildId}.json`);
+          const filePath = path5.join(libraryPath, `${buildId}.json`);
           if (!fs3.existsSync(filePath)) {
             throw new Error(`Build not found in library: ${buildId}`);
           }
@@ -7701,7 +10041,7 @@ ${code}`
           throw new Error(`File not found: ${filePath}`);
         }
         const fileContent = fs3.readFileSync(filePath);
-        const fileName = path4.basename(filePath);
+        const fileName = path5.basename(filePath);
         if (assetType === "Decal" && this.cookieClient.hasCookie()) {
           const result2 = await this.cookieClient.uploadDecal(fileContent, displayName, description || "");
           return {
@@ -7926,12 +10266,12 @@ ${code}`
           return { content: [{ type: "text", text: JSON.stringify({ error: "plugin returned no base64 payload" }) }] };
         }
         const bytes = Buffer.from(response.base64, "base64");
-        const resolved = path4.resolve(outputPath);
+        const resolved = path5.resolve(outputPath);
         try {
-          fs3.mkdirSync(path4.dirname(resolved), { recursive: true });
+          fs3.mkdirSync(path5.dirname(resolved), { recursive: true });
           fs3.writeFileSync(resolved, bytes);
-        } catch (err) {
-          return { content: [{ type: "text", text: JSON.stringify({ error: `failed to write ${resolved}: ${err.message}` }) }] };
+        } catch (err2) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: `failed to write ${resolved}: ${err2.message}` }) }] };
         }
         return {
           content: [{
@@ -7962,11 +10302,11 @@ ${code}`
         let bytes;
         let sourceLabel;
         if (source.path !== void 0) {
-          const resolved = path4.resolve(source.path);
+          const resolved = path5.resolve(source.path);
           try {
             bytes = fs3.readFileSync(resolved);
-          } catch (err) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: `failed to read ${resolved}: ${err.message}` }) }] };
+          } catch (err2) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `failed to read ${resolved}: ${err2.message}` }) }] };
           }
           sourceLabel = resolved;
         } else if (source.url !== void 0) {
@@ -7995,15 +10335,15 @@ ${code}`
               return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url}: downloaded ${arr.byteLength} bytes exceeds ${MAX_IMPORT_BYTES} byte cap` }) }] };
             }
             bytes = Buffer.from(arr);
-          } catch (err) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url} failed: ${err.message}` }) }] };
+          } catch (err2) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url} failed: ${err2.message}` }) }] };
           }
           sourceLabel = source.url;
         } else {
           try {
             bytes = Buffer.from(source.base64, "base64");
-          } catch (err) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: `base64 decode failed: ${err.message}` }) }] };
+          } catch (err2) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `base64 decode failed: ${err2.message}` }) }] };
           }
           sourceLabel = `base64(${bytes.length}B)`;
         }
@@ -8107,26 +10447,42 @@ var init_proxy_bridge_service = __esm({
     init_bridge_service();
     ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
       primaryBaseUrl;
+      authToken;
       proxyInstanceId;
       proxyRequestTimeout = 3e4;
       cachedInstances = [];
       refreshTimer;
       static REFRESH_INTERVAL_MS = 1e3;
-      constructor(primaryBaseUrl) {
+      constructor(primaryBaseUrl, authToken) {
         super();
         this.primaryBaseUrl = primaryBaseUrl;
+        this.authToken = authToken;
         this.proxyInstanceId = uuidv42();
         this.refreshInstances();
         this.refreshTimer = setInterval(() => this.refreshInstances(), _ProxyBridgeService.REFRESH_INTERVAL_MS);
       }
+      authHeaders(extra) {
+        const headers = { ...extra };
+        if (this.authToken)
+          headers["X-MCP-Auth"] = this.authToken;
+        return headers;
+      }
       async refreshInstances() {
         try {
-          const res = await fetch(`${this.primaryBaseUrl}/instances`);
+          const res = await fetch(`${this.primaryBaseUrl}/instances`, {
+            headers: this.authHeaders()
+          });
           if (!res.ok)
             return;
           const body = await res.json();
           if (Array.isArray(body.instances)) {
+            const previousKeys = new Set(this.cachedInstances.map((instance) => `${instance.pluginSessionId}\0${instance.instanceId}\0${instance.role}\0${instance.connectedAt}`));
             this.cachedInstances = body.instances;
+            for (const instance of body.instances) {
+              const key = `${instance.pluginSessionId}\0${instance.instanceId}\0${instance.role}\0${instance.connectedAt}`;
+              if (!previousKeys.has(key))
+                this.notifyInstanceRegistered(toPublic(instance));
+            }
           }
         } catch {
         }
@@ -8137,7 +10493,7 @@ var init_proxy_bridge_service = __esm({
       async unregisterInstanceIdEverywhere(instanceId) {
         const response = await fetch(`${this.primaryBaseUrl}/unregister-instance-id`, {
           method: "POST",
-          headers: { "Content-Type": "application/json" },
+          headers: this.authHeaders({ "Content-Type": "application/json" }),
           body: JSON.stringify({ instanceId })
         });
         if (!response.ok) {
@@ -8166,7 +10522,7 @@ var init_proxy_bridge_service = __esm({
         try {
           const response = await fetch(`${this.primaryBaseUrl}/proxy`, {
             method: "POST",
-            headers: { "Content-Type": "application/json" },
+            headers: this.authHeaders({ "Content-Type": "application/json" }),
             body: JSON.stringify({
               endpoint,
               data,
@@ -8186,12 +10542,12 @@ var init_proxy_bridge_service = __esm({
             throw new Error(result.error);
           }
           return result.response;
-        } catch (err) {
+        } catch (err2) {
           clearTimeout(timeoutId);
-          if (err.name === "AbortError") {
+          if (err2.name === "AbortError") {
             throw new Error("Proxy request timeout");
           }
-          throw err;
+          throw err2;
         }
       }
       cleanupOldRequests() {
@@ -8211,6 +10567,7 @@ var init_server = __esm({
   "../core/dist/server.js"() {
     "use strict";
     init_http_server();
+    init_auth();
     init_tools();
     init_bridge_service();
     init_proxy_bridge_service();
@@ -8280,14 +10637,28 @@ var init_server = __esm({
       }
       async run() {
         const basePort = process.env.ROBLOX_STUDIO_PORT ? parseInt(process.env.ROBLOX_STUDIO_PORT) : 58741;
-        const host = process.env.ROBLOX_STUDIO_HOST || "0.0.0.0";
+        const host = process.env.ROBLOX_STUDIO_HOST?.trim() || "127.0.0.1";
+        if (host !== "127.0.0.1" && host !== "localhost" && host !== "::1") {
+          console.error(`WARNING: ROBLOX_STUDIO_HOST=${host} exposes the MCP bridge beyond this machine. Anyone who can reach the port and knows the auth token can control Roblox Studio.`);
+        }
+        const auth = resolveAuthToken();
+        const security = {
+          authToken: auth.token,
+          authTokenHint: auth.source === "env" ? "The token comes from ROBLOX_STUDIO_AUTH_TOKEN." : auth.filePath ? `The token is in ${auth.filePath}.` : void 0,
+          allowedOrigins: (process.env.ROBLOX_STUDIO_ALLOWED_ORIGINS || "").split(",").map((o) => o.trim()).filter((o) => o !== "")
+        };
+        if (auth.source === "disabled") {
+          console.error("WARNING: ROBLOX_STUDIO_NO_AUTH is set - tool endpoints accept unauthenticated requests.");
+        } else if (auth.filePath) {
+          console.error(`Auth token loaded from ${auth.filePath} (HTTP clients must send X-MCP-Auth or Authorization: Bearer)`);
+        }
         let bridgeMode = "primary";
         let httpHandle;
         let primaryApp;
         let boundPort = 0;
         let promotionInterval;
         try {
-          primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config);
+          primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config, security);
           const result = await listenWithRetry(primaryApp, host, basePort, 1);
           httpHandle = result.server;
           boundPort = result.port;
@@ -8296,7 +10667,7 @@ var init_server = __esm({
         } catch {
           bridgeMode = "proxy";
           primaryApp = void 0;
-          const proxyBridge = new ProxyBridgeService(`http://localhost:${basePort}`);
+          const proxyBridge = new ProxyBridgeService(`http://localhost:${basePort}`, auth.token);
           this.bridge = proxyBridge;
           this.tools = new RobloxStudioTools(this.bridge);
           console.error(`Port ${basePort} in use - entering proxy mode (forwarding to localhost:${basePort})`);
@@ -8304,7 +10675,7 @@ var init_server = __esm({
           promotionInterval = setInterval(async () => {
             const candidateBridge = new BridgeService();
             const candidateTools = new RobloxStudioTools(candidateBridge);
-            const candidateApp = createHttpServer(candidateTools, candidateBridge, this.allowedToolNames, this.config);
+            const candidateApp = createHttpServer(candidateTools, candidateBridge, this.allowedToolNames, this.config, security);
             try {
               const result = await listenWithRetry(candidateApp, host, basePort, 1);
               const oldBridge = this.bridge;
@@ -8329,7 +10700,7 @@ var init_server = __esm({
         let legacyHandle;
         let legacyApp;
         if (boundPort !== LEGACY_PORT && bridgeMode === "primary") {
-          legacyApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config);
+          legacyApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config, security);
           try {
             const result = await listenWithRetry(legacyApp, host, LEGACY_PORT, 1);
             legacyHandle = result.server;
@@ -9359,7 +11730,7 @@ var init_definitions = __esm({
       {
         name: "manage_instance",
         category: "write",
-        description: 'Launch, close, inspect, and find revisions for Studio instances. Use action="launch" with source="baseplate" for a blank place, or source="local_file" with local_place_file for a local place; neither uses place_id. Use action="list_place_versions" with place_id to retrieve version numbers through Open Cloud asset versions, then action="launch" with source="place_revision", place_id, and place_version to open an older revision. action="close" can close an MCP-managed instance or an explicitly connected edit instance by instance_id. action="launch" source="published_place" opens the latest published place and is blocked if that place_id is already connected; source="place_revision" is allowed because Studio opens explicit past revisions as anonymous local copies. Requires ROBLOX_OPEN_CLOUD_API_KEY with asset:read for list_place_versions.',
+        description: 'Launch, close, inspect, and find revisions for Studio instances. Every launch returns launch_id, native pid, source, and lifecycle state; status and close accept launch_id before the plugin connects and instance_id after association. Use action="launch" with source="baseplate" for a blank place, or source="local_file" with local_place_file for a local place; neither uses place_id. Use action="list_place_versions" with place_id to retrieve version numbers through Open Cloud asset versions, then action="launch" with source="place_revision", place_id, and place_version to open an older revision. action="launch" source="published_place" opens the latest published place and is blocked if that place_id is already connected; source="place_revision" is allowed because Studio opens explicit past revisions as anonymous local copies. Requires ROBLOX_OPEN_CLOUD_API_KEY with asset:read for list_place_versions.',
         inputSchema: {
           type: "object",
           properties: {
@@ -9387,11 +11758,11 @@ var init_definitions = __esm({
             },
             wait_for_connection: {
               type: "boolean",
-              description: 'For action="launch": wait until the MCP plugin connects and return instance_id (default true).'
+              description: 'For action="launch": wait until the MCP plugin connects and return instance_id (default true). false returns launch_id immediately and continues association/failure tracking asynchronously.'
             },
             timeout_ms: {
               type: "number",
-              description: 'For action="launch": max milliseconds to wait for plugin connection (default 120000).'
+              description: 'For action="launch": max milliseconds for plugin connection (default 120000). The deadline also applies asynchronously when wait_for_connection=false.'
             },
             max_page_size: {
               type: "number",
@@ -9403,7 +11774,11 @@ var init_definitions = __esm({
             },
             instance_id: {
               type: "string",
-              description: 'For action="close" or action="status": Studio instance to inspect or close. close accepts MCP-managed instances and explicitly connected edit instances.'
+              description: 'For action="close" or action="status": connected Studio instance to inspect or close. Mutually exclusive with launch_id.'
+            },
+            launch_id: {
+              type: "string",
+              description: 'For action="close" or action="status": opaque identifier returned by launch. Works before plugin connection and for retained terminal launch status. Mutually exclusive with instance_id.'
             }
           },
           required: ["action"]
@@ -10186,7 +12561,7 @@ CYLINDER AXIS: Roblox cylinders extend along the X axis. For upright cylinders,
 EXAMPLE - compact cabin (17 lines):
 room(0,0,0,8,4,6,"a","b","a")
 roof(0,4,0,8,6,"gable","c")
-wall(-4,0,-2,4,0,-2,4,1,"a")
+wall(-4,-2,4,-2,4,1,"a")
 part(0,2,3,3,3,0.3,"a","Block",0.4)
 row(-2,0,-1,3,0,2,(i,cx,cy,cz)=>{pew(cx,0,cz,3,2,"d")})
 column(-3,0,-2,4,0.5,"a","b")
@@ -10981,6 +13356,27 @@ part(0,2,0,2,1,1,"b")`,
           required: ["pattern", "replacement"]
         }
       },
+      // === Installed Studio Skills ===
+      {
+        name: "get_roblox_skills",
+        category: "read",
+        description: `List or retrieve Roblox-authored skills embedded in the locally installed Studio Assistant bundle. This reads the installed Assistant.rbxm directly, so it does not require a connected Studio place or Roblox's built-in MCP. Use action="list" to discover available names, then action="get" to retrieve the exact Markdown for one skill.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["list", "get"],
+              description: "List installed built-in skills or get one skill document."
+            },
+            name: {
+              type: "string",
+              description: 'Skill name returned by action="list". Required for action="get"; both canonical rbx-* and embedded source names are accepted.'
+            }
+          },
+          required: ["action"]
+        }
+      },
       // === Documentation ===
       {
         name: "get_roblox_docs",
@@ -11164,15 +13560,15 @@ part(0,2,0,2,1,1,"b")`,
 });
 
 // ../core/dist/install-plugin-helpers.js
-import { existsSync as existsSync4, readFileSync as readFileSync5, unlinkSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7, unlinkSync } from "fs";
 import { execSync } from "child_process";
-import { join as join4 } from "path";
-import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
 function isWSL() {
   if (process.platform !== "linux")
     return false;
   try {
-    const v = readFileSync5("/proc/version", "utf8");
+    const v = readFileSync7("/proc/version", "utf8");
     return /microsoft|wsl/i.test(v);
   } catch {
     return false;
@@ -11190,7 +13586,7 @@ function getWindowsUserPluginsDir() {
     }).toString().trim();
     if (!linuxPath)
       return null;
-    return join4(linuxPath, "Roblox", "Plugins");
+    return join6(linuxPath, "Roblox", "Plugins");
   } catch {
     return null;
   }
@@ -11199,7 +13595,7 @@ function getPluginsFolder() {
   if (process.env.MCP_PLUGINS_DIR)
     return process.env.MCP_PLUGINS_DIR;
   if (process.platform === "win32") {
-    return join4(process.env.LOCALAPPDATA || join4(homedir4(), "AppData", "Local"), "Roblox", "Plugins");
+    return join6(process.env.LOCALAPPDATA || join6(homedir5(), "AppData", "Local"), "Roblox", "Plugins");
   }
   if (isWSL()) {
     const win = getWindowsUserPluginsDir();
@@ -11207,18 +13603,18 @@ function getPluginsFolder() {
       return win;
     console.warn("[install-plugin] WSL detected but could not resolve Windows %LOCALAPPDATA%. Falling back to ~/Documents/Roblox/Plugins/ - you will likely need to copy the rbxmx to /mnt/c/Users/<you>/AppData/Local/Roblox/Plugins/ manually. Set MCP_PLUGINS_DIR to skip detection.");
   }
-  return join4(homedir4(), "Documents", "Roblox", "Plugins");
+  return join6(homedir5(), "Documents", "Roblox", "Plugins");
 }
 function handleVariantConflict({ pluginsFolder, otherAssetName, replace, log = console.log, warn = console.warn }) {
-  const otherDest = join4(pluginsFolder, otherAssetName);
-  if (!existsSync4(otherDest))
+  const otherDest = join6(pluginsFolder, otherAssetName);
+  if (!existsSync6(otherDest))
     return;
   if (replace) {
     try {
       unlinkSync(otherDest);
       log(`Removed conflicting ${otherAssetName}.`);
-    } catch (err) {
-      warn(`[install-plugin] Could not remove ${otherDest}: ${err}. Continuing.`);
+    } catch (err2) {
+      warn(`[install-plugin] Could not remove ${otherDest}: ${err2}. Continuing.`);
     }
     return;
   }
@@ -11247,6 +13643,7 @@ var init_dist = __esm({
     init_opencloud_client();
     init_install_plugin_helpers();
     init_roblox_cookie_client();
+    init_studio_skills();
   }
 });
 
@@ -11256,13 +13653,13 @@ __export(install_plugin_exports, {
   installBundledPlugin: () => installBundledPlugin,
   installPlugin: () => installPlugin
 });
-import { copyFileSync as copyFileSync2, createWriteStream, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync6, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname3, join as join5 } from "path";
+import { copyFileSync as copyFileSync2, createWriteStream, existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync8, unlinkSync as unlinkSync2 } from "fs";
+import { dirname as dirname5, join as join7 } from "path";
 import { fileURLToPath } from "url";
 import { get } from "https";
 function httpsGet(url) {
-  return new Promise((resolve4, reject) => {
-    const req = get(url, { headers: { "User-Agent": "robloxstudio-mcp-inspector" } }, resolve4);
+  return new Promise((resolve5, reject) => {
+    const req = get(url, { headers: { "User-Agent": "robloxstudio-mcp-inspector" } }, resolve5);
     req.on("error", reject);
     req.setTimeout(TIMEOUT_MS, () => {
       req.destroy(new Error(`Request timed out after ${TIMEOUT_MS}ms`));
@@ -11280,21 +13677,21 @@ async function download(url, dest, redirects = 0) {
   if (res.statusCode !== 200) {
     throw new Error(`Download failed: HTTP ${res.statusCode}`);
   }
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const file = createWriteStream(dest);
-    const cleanup = (err) => {
+    const cleanup = (err2) => {
       file.close(() => {
         try {
           unlinkSync2(dest);
         } catch {
         }
-        reject(err);
+        reject(err2);
       });
     };
     res.pipe(file);
     file.on("finish", () => {
       file.close();
-      resolve4();
+      resolve5();
     });
     file.on("error", cleanup);
     res.on("error", cleanup);
@@ -11317,8 +13714,8 @@ function prepareInstall({
   warn
 }) {
   const pluginsFolder = getPluginsFolder();
-  if (!existsSync5(pluginsFolder)) {
-    mkdirSync4(pluginsFolder, { recursive: true });
+  if (!existsSync7(pluginsFolder)) {
+    mkdirSync5(pluginsFolder, { recursive: true });
   }
   handleVariantConflict({
     pluginsFolder,
@@ -11330,23 +13727,23 @@ function prepareInstall({
   return pluginsFolder;
 }
 function bundledAssetPath() {
-  const currentDir = dirname3(fileURLToPath(import.meta.url));
+  const currentDir = dirname5(fileURLToPath(import.meta.url));
   const candidates = [
-    join5(currentDir, "..", "studio-plugin", ASSET_NAME),
-    join5(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
+    join7(currentDir, "..", "studio-plugin", ASSET_NAME),
+    join7(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
   ];
-  return candidates.find((candidate) => existsSync5(candidate)) ?? null;
+  return candidates.find((candidate) => existsSync7(candidate)) ?? null;
 }
 function packageVersion() {
-  const currentDir = dirname3(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync6(join5(currentDir, "..", "package.json"), "utf8"));
+  const currentDir = dirname5(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync8(join7(currentDir, "..", "package.json"), "utf8"));
   if (!pkg.version) {
     throw new Error("Package version not found");
   }
   return pkg.version;
 }
 function bundledPluginVersion(source) {
-  const match = readFileSync6(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
+  const match = readFileSync8(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
   return match ? match[1] : null;
 }
 function assertBundledPluginVersion(source) {
@@ -11359,9 +13756,9 @@ function assertBundledPluginVersion(source) {
   }
 }
 function filesMatch(a, b) {
-  if (!existsSync5(b)) return false;
-  const aBytes = readFileSync6(a);
-  const bBytes = readFileSync6(b);
+  if (!existsSync7(b)) return false;
+  const aBytes = readFileSync8(a);
+  const bBytes = readFileSync8(b);
   return aBytes.length === bBytes.length && aBytes.equals(bBytes);
 }
 async function installBundledPlugin(options = {}) {
@@ -11374,7 +13771,7 @@ async function installBundledPlugin(options = {}) {
   }
   assertBundledPluginVersion(source);
   const pluginsFolder = prepareInstall({ replaceVariant, log, warn });
-  const dest = join5(pluginsFolder, ASSET_NAME);
+  const dest = join7(pluginsFolder, ASSET_NAME);
   if (filesMatch(source, dest)) return;
   copyFileSync2(source, dest);
   log(`Installed ${ASSET_NAME} to ${dest}`);
@@ -11387,7 +13784,7 @@ async function installPlugin(options = {}) {
   const bundled = bundledAssetPath();
   if (bundled) {
     assertBundledPluginVersion(bundled);
-    const dest2 = join5(pluginsFolder, ASSET_NAME);
+    const dest2 = join7(pluginsFolder, ASSET_NAME);
     if (filesMatch(bundled, dest2)) {
       log(`${ASSET_NAME} already installed.`);
       return;
@@ -11402,7 +13799,7 @@ async function installPlugin(options = {}) {
   if (!asset) {
     throw new Error(`${ASSET_NAME} not found in release ${release.tag_name}`);
   }
-  const dest = join5(pluginsFolder, ASSET_NAME);
+  const dest = join7(pluginsFolder, ASSET_NAME);
   log(`Downloading ${ASSET_NAME} from ${release.tag_name}...`);
   await download(asset.browser_download_url, dest);
   log(`Installed to ${dest}`);
@@ -11425,8 +13822,8 @@ init_dist();
 import { createRequire } from "module";
 if (process.argv.includes("--install-plugin")) {
   const { installPlugin: installPlugin2 } = await Promise.resolve().then(() => (init_install_plugin(), install_plugin_exports));
-  await installPlugin2().catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
+  await installPlugin2().catch((err2) => {
+    console.error(err2 instanceof Error ? err2.message : String(err2));
     process.exitCode = 1;
   });
 } else {
@@ -11435,9 +13832,9 @@ if (process.argv.includes("--install-plugin")) {
     await installBundledPlugin2({
       log: (message) => console.error(`[install-plugin] ${message}`),
       warn: (message) => console.error(message)
-    }).catch((err) => {
+    }).catch((err2) => {
       console.error(
-        `[install-plugin] Auto-install skipped: ${err instanceof Error ? err.message : String(err)}`
+        `[install-plugin] Auto-install skipped: ${err2 instanceof Error ? err2.message : String(err2)}`
       );
     });
   }