@chrrxs/robloxstudio-mcp-inspector 2.21.0 → 2.22.1

package/dist/index.js

@@ -32,7 +32,7 @@ function publishedInstanceId(placeId) {
     return void 0;
   return `place:${Math.trunc(placeId)}`;
 }
-var RoutingFailure, STALE_INSTANCE_MS, INSTANCE_ALIAS_TTL_MS, BridgeService;
+var RoutingFailure, STALE_INSTANCE_MS, DUPLICATE_TAKEOVER_MS, INSTANCE_ALIAS_TTL_MS, BridgeService;
 var init_bridge_service = __esm({
   "../core/dist/bridge-service.js"() {
     "use strict";
@@ -45,13 +45,33 @@ var init_bridge_service = __esm({
       }
     };
     STALE_INSTANCE_MS = 3e4;
+    DUPLICATE_TAKEOVER_MS = 3e3;
     INSTANCE_ALIAS_TTL_MS = 5 * 60 * 1e3;
     BridgeService = class {
       pendingRequests = /* @__PURE__ */ new Map();
       // 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;
       }
@@ -148,16 +168,20 @@ var init_bridge_service = __esm({
         }
         const existing = Array.from(this.instances.values()).find((i) => i.instanceId === instanceId && i.role === assignedRole && i.pluginSessionId !== pluginSessionId);
         if (existing) {
-          return {
-            ok: false,
-            error: {
-              code: "duplicate_instance_role",
-              message: `Another plugin is already registered as (${instanceId}, ${assignedRole}).`,
-              existing: toPublic(existing)
-            }
-          };
+          if (Date.now() - existing.lastActivity > DUPLICATE_TAKEOVER_MS) {
+            this.unregisterInstance(existing.pluginSessionId);
+          } else {
+            return {
+              ok: false,
+              error: {
+                code: "duplicate_instance_role",
+                message: `Another plugin is already registered as (${instanceId}, ${assignedRole}).`,
+                existing: toPublic(existing)
+              }
+            };
+          }
         }
-        this.instances.set(pluginSessionId, {
+        const registered = {
           pluginSessionId,
           instanceId,
           role: assignedRole,
@@ -171,7 +195,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 +395,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 +410,7 @@ var init_bridge_service = __esm({
             targetRole,
             timestamp: Date.now(),
             inFlight: false,
-            resolve: resolve4,
+            resolve: resolve5,
             reject,
             timeoutId,
             timeoutMs: effectiveTimeoutMs
@@ -480,6 +506,93 @@ function cacheSet(key, entry) {
 function docUrl(category, name) {
   return `${DOCS_BASE_URL}/${category}/${encodeURIComponent(name)}.md`;
 }
+function normalizeDocName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function queryNameVariants(value) {
+  const parts = value.split(/[./:#\s]+/).filter(Boolean);
+  const variants = /* @__PURE__ */ new Set([normalizeDocName(value)]);
+  for (const part of parts) {
+    const normalized = normalizeDocName(part);
+    if (normalized && normalized !== "enum")
+      variants.add(normalized);
+  }
+  return Array.from(variants).filter(Boolean);
+}
+function editDistance(left, right) {
+  const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= left.length; i++) {
+    let diagonal = previous[0];
+    previous[0] = i;
+    for (let j = 1; j <= right.length; j++) {
+      const above = previous[j];
+      previous[j] = Math.min(previous[j] + 1, previous[j - 1] + 1, diagonal + (left[i - 1] === right[j - 1] ? 0 : 1));
+      diagonal = above;
+    }
+  }
+  return previous[right.length];
+}
+async function fetchDocCatalog() {
+  if (catalogCache && Date.now() - catalogCache.fetchedAt <= CACHE_TTL_MS) {
+    return catalogCache.pages;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(DOCS_INDEX_URL, {
+      signal: controller.signal,
+      headers: { Accept: "text/html" }
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    throw new Error(`Failed to fetch Roblox docs index: HTTP ${response.status}`);
+  }
+  const html = await response.text();
+  const pages = /* @__PURE__ */ new Map();
+  const routePattern = /reference\/engine\/(classes|enums|datatypes|libraries|globals)\/([A-Za-z0-9_]+)/g;
+  for (const match of html.matchAll(routePattern)) {
+    const category = match[1];
+    const name = match[2];
+    const key = `${category}/${name}`;
+    pages.set(key, { category, name, url: docUrl(category, name) });
+  }
+  const result = Array.from(pages.values());
+  if (result.length === 0) {
+    throw new Error("Roblox docs index did not contain any engine reference pages");
+  }
+  catalogCache = { fetchedAt: Date.now(), pages: result };
+  return result;
+}
+async function recommendRobloxDocs(category, name, limit = 5) {
+  const variants = queryNameVariants(name);
+  const catalog = await fetchDocCatalog();
+  return catalog.map((page) => {
+    const candidate = normalizeDocName(page.name);
+    const similarity = Math.max(...variants.map((variant) => {
+      if (variant === candidate)
+        return 2;
+      const distance = editDistance(variant, candidate);
+      const ratio = 1 - distance / Math.max(variant.length, candidate.length, 1);
+      const prefixBonus = variant.startsWith(candidate) || candidate.startsWith(variant) ? 0.15 : 0;
+      const containsBonus = variant.includes(candidate) || candidate.includes(variant) ? 0.05 : 0;
+      return ratio + prefixBonus + containsBonus;
+    }));
+    return { page, score: similarity + (page.category === category ? 0.08 : 0) };
+  }).sort((a, b) => b.score - a.score || a.page.name.localeCompare(b.page.name)).slice(0, Math.max(1, limit)).map(({ page }) => page);
+}
+function recommendationsMarkdown(requestedCategory, requestedName, recommendations) {
+  const lines = recommendations.map((page) => `- [${page.category}/${page.name}](${page.url}) \u2014 retry with \`name="${page.name}", doc_type="${page.category}"\``);
+  return [
+    `# No exact Roblox documentation page found`,
+    "",
+    `The lookup \`${requestedCategory}/${requestedName}\` did not resolve. Recommended pages:`,
+    "",
+    ...lines
+  ].join("\n");
+}
 async function fetchRobloxDoc(category, name) {
   const key = `${category}/${name}`;
   const cached = cacheGet(key);
@@ -544,7 +657,24 @@ function extractSection(markdown, section) {
   return lines.slice(start, end).join("\n").trimEnd();
 }
 async function getRobloxDoc(category, name, section) {
-  const markdown = await fetchRobloxDoc(category, name);
+  let markdown;
+  try {
+    markdown = await fetchRobloxDoc(category, name);
+  } catch (error) {
+    if (!(error instanceof DocNotFoundError))
+      throw error;
+    try {
+      const recommendations = await recommendRobloxDocs(category, name);
+      return {
+        content: recommendationsMarkdown(category, name, recommendations),
+        truncated: false,
+        sections: [],
+        recommendations
+      };
+    } catch {
+      throw error;
+    }
+  }
   const sections = listSections(markdown);
   if (section) {
     const extracted = extractSection(markdown, section);
@@ -563,12 +693,13 @@ async function getRobloxDoc(category, name, section) {
   }
   return { content: markdown, truncated: false, sections };
 }
-var DOC_CATEGORIES, DOCS_BASE_URL, FETCH_TIMEOUT_MS, CACHE_TTL_MS, NEGATIVE_CACHE_TTL_MS, MAX_CACHE_ENTRIES, MAX_DOC_CHARS, cache, DocNotFoundError;
+var DOC_CATEGORIES, DOCS_BASE_URL, DOCS_INDEX_URL, FETCH_TIMEOUT_MS, CACHE_TTL_MS, NEGATIVE_CACHE_TTL_MS, MAX_CACHE_ENTRIES, MAX_DOC_CHARS, cache, catalogCache, DocNotFoundError;
 var init_roblox_docs = __esm({
   "../core/dist/roblox-docs.js"() {
     "use strict";
     DOC_CATEGORIES = ["classes", "enums", "datatypes", "libraries", "globals"];
     DOCS_BASE_URL = "https://create.roblox.com/docs/reference/engine";
+    DOCS_INDEX_URL = DOCS_BASE_URL;
     FETCH_TIMEOUT_MS = 15e3;
     CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
     NEGATIVE_CACHE_TTL_MS = 5 * 60 * 1e3;
@@ -686,8 +817,8 @@ function resolveAuthToken() {
     } catch {
     }
     return { token: fresh, source: "file", filePath };
-  } catch (err) {
-    console.error(`[auth] Could not read/create ${filePath} (${err instanceof Error ? err.message : err}). Using an in-memory token for this process; set ROBLOX_STUDIO_AUTH_TOKEN to share one across sessions.`);
+  } 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" };
   }
 }
@@ -811,7 +942,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     next();
   });
   const authToken = security?.authToken;
-  const authRequired = (path5) => path5 === "/mcp" || path5.startsWith("/mcp/") || path5 === "/proxy" || path5 === "/instances" || path5 === "/unregister-instance-id";
+  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();
@@ -891,11 +1022,11 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
         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;
@@ -1046,8 +1177,8 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     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) {
@@ -1159,19 +1290,19 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   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;
       }
     }
@@ -1179,16 +1310,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);
     });
   });
 }
@@ -1200,6 +1331,7 @@ var init_http_server = __esm({
     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),
@@ -1382,8 +1514,8 @@ function runRestrictedScript(code, globals, options) {
   let ast;
   try {
     ast = acorn.parse(code, { ecmaVersion: 2022, sourceType: "script" });
-  } catch (err) {
-    throw new Error(`Syntax error: ${err.message}`);
+  } catch (err2) {
+    throw new Error(`Syntax error: ${err2.message}`);
   }
   const globalScope = new Scope(void 0, true);
   for (const [name, value] of Object.entries(globals)) {
@@ -1694,15 +1826,15 @@ function runRestrictedScript(code, globals, options) {
       case "TryStatement": {
         try {
           execute(node.block, scope);
-        } catch (err) {
-          if (err instanceof BreakSignal || err instanceof ContinueSignal || err instanceof ReturnSignal)
-            throw err;
-          if (err instanceof ScriptTimeoutError)
-            throw err;
+        } 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 = err instanceof Error ? { message: err.message } : err;
+              const message = err2 instanceof Error ? { message: err2.message } : err2;
               bindPattern(node.handler.param, message, catchScope, "let");
             }
             execute(node.handler.body, catchScope);
@@ -2580,11 +2712,11 @@ function runBuildExecutor(code, palette, seed, options) {
   };
   try {
     runRestrictedScript(code, sandbox, { timeoutMs: timeout });
-  } catch (err) {
-    if (err instanceof ScriptTimeoutError) {
+  } 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 ?? String(err)}`);
+    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.");
@@ -2843,7 +2975,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}`);
       }
@@ -2964,7 +3096,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";
@@ -2973,6 +3105,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()) {
@@ -3000,12 +3133,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);
@@ -3177,41 +3319,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);
           }
         }
@@ -3270,6 +3423,63 @@ function toStudioLaunchArg(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)
@@ -3301,8 +3511,8 @@ function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch (err) {
-    return err.code === "EPERM";
+  } catch (err2) {
+    return err2.code === "EPERM";
   }
 }
 function sweepStaleBaseplateFiles() {
@@ -3395,7 +3605,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 [];
   }
@@ -3459,7 +3669,7 @@ 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, "/"));
@@ -3477,6 +3687,8 @@ var init_studio_instance_manager = __esm({
     StudioInstanceManager = class {
       managedByInstanceId = /* @__PURE__ */ new Map();
       pending = /* @__PURE__ */ new Set();
+      monitors = /* @__PURE__ */ new Map();
+      connectionTimers = /* @__PURE__ */ new Map();
       registry;
       processAdapter;
       constructor(options = {}) {
@@ -3485,6 +3697,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);
@@ -3493,27 +3708,82 @@ 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);
@@ -3522,11 +3792,35 @@ var init_studio_instance_manager = __esm({
           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,
@@ -3535,29 +3829,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);
@@ -3568,33 +3907,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.`);
@@ -3602,8 +3932,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,
@@ -3612,7 +3941,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({
@@ -3638,15 +3967,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);
@@ -3721,6 +4053,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;
@@ -3746,10 +4081,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;
       }
-      markClosedInRegistry(record) {
-        if (record.recordId)
-          this.registry.markClosed(record.recordId, record.closedAt ?? Date.now());
+      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);
+      }
+      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)
@@ -3762,6 +4151,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,
@@ -3771,18 +4161,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,
@@ -3791,6 +4189,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,
@@ -3976,6 +4381,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)
@@ -4995,7 +6376,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,
@@ -5020,7 +6401,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);
@@ -5082,7 +6463,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)
@@ -5543,6 +6924,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;
@@ -5610,10 +6992,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")');
@@ -5966,8 +7390,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: [
             {
@@ -6084,9 +7508,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);
@@ -7010,8 +8434,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;
             }
@@ -7073,8 +8497,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;
             }
@@ -7089,8 +8513,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;
           }
@@ -7158,11 +8582,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) {
@@ -7178,6 +8609,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];
@@ -7186,12 +8621,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()
         };
@@ -7203,6 +8651,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");
         }
@@ -7230,18 +8682,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()
             });
           }
@@ -7257,14 +8717,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."
               });
             }
@@ -7311,7 +8789,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."
           });
         }
@@ -7338,24 +8816,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."
         });
       }
@@ -7538,16 +9026,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;
@@ -7873,14 +9361,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;
       }
@@ -7894,7 +9382,7 @@ ${code}`
         }
       }
       static ensureWritableDirectory(candidate, label) {
-        const resolved = path4.resolve(candidate);
+        const resolved = path5.resolve(candidate);
         try {
           fs3.mkdirSync(resolved, { recursive: true });
         } catch (error) {
@@ -7915,11 +9403,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");
@@ -7933,12 +9421,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 {
@@ -7960,8 +9448,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 });
           }
@@ -8062,8 +9550,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 });
         }
@@ -8121,8 +9609,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 });
         }
@@ -8150,13 +9638,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}`);
           }
@@ -8183,13 +9671,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", "")}`,
@@ -8228,7 +9716,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}`);
         }
@@ -8315,7 +9803,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}`);
           }
@@ -8663,7 +10151,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 {
@@ -8888,12 +10376,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: [{
@@ -8924,11 +10412,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) {
@@ -8957,15 +10445,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)`;
         }
@@ -9098,7 +10586,13 @@ var init_proxy_bridge_service = __esm({
             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 {
         }
@@ -9158,12 +10652,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() {
@@ -10346,7 +11840,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: {
@@ -10374,11 +11868,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",
@@ -10390,7 +11884,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"]
@@ -11968,11 +13466,32 @@ 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",
         category: "read",
-        description: 'Fetch official Roblox engine API documentation as markdown from create.roblox.com. Call this BEFORE writing or editing code that uses an engine class, enum, datatype, or Luau library you are not fully certain about (e.g. ProximityPrompt, Enum.KeyCode, CFrame, TweenService) \u2014 the page includes the description, properties, methods, events, and code samples. Results are cached, so repeat lookups are cheap. Very large pages are truncated with a section index; pass section (e.g. "Properties", "Methods", "Events") to read one section in full.',
+        description: 'Fetch official Roblox engine API documentation as markdown from create.roblox.com. Call this BEFORE writing or editing code that uses an engine class, enum, datatype, or Luau library you are not fully certain about (e.g. ProximityPrompt, Enum.KeyCode, CFrame, TweenService) \u2014 the page includes the description, properties, methods, events, and code samples. Unresolved names return ranked recommendations from the official engine index, including pages in other doc categories. Results are cached, so repeat lookups are cheap. Very large pages are truncated with a section index; pass section (e.g. "Properties", "Methods", "Events") to read one section in full.',
         inputSchema: {
           type: "object",
           properties: {
@@ -12151,15 +13670,15 @@ part(0,2,0,2,1,1,"b")`,
 });
 
 // ../core/dist/install-plugin-helpers.js
-import { existsSync as existsSync5, readFileSync as readFileSync6, unlinkSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7, unlinkSync } from "fs";
 import { execSync } from "child_process";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { homedir as homedir5 } from "os";
 function isWSL() {
   if (process.platform !== "linux")
     return false;
   try {
-    const v = readFileSync6("/proc/version", "utf8");
+    const v = readFileSync7("/proc/version", "utf8");
     return /microsoft|wsl/i.test(v);
   } catch {
     return false;
@@ -12177,7 +13696,7 @@ function getWindowsUserPluginsDir() {
     }).toString().trim();
     if (!linuxPath)
       return null;
-    return join5(linuxPath, "Roblox", "Plugins");
+    return join6(linuxPath, "Roblox", "Plugins");
   } catch {
     return null;
   }
@@ -12186,7 +13705,7 @@ function getPluginsFolder() {
   if (process.env.MCP_PLUGINS_DIR)
     return process.env.MCP_PLUGINS_DIR;
   if (process.platform === "win32") {
-    return join5(process.env.LOCALAPPDATA || join5(homedir5(), "AppData", "Local"), "Roblox", "Plugins");
+    return join6(process.env.LOCALAPPDATA || join6(homedir5(), "AppData", "Local"), "Roblox", "Plugins");
   }
   if (isWSL()) {
     const win = getWindowsUserPluginsDir();
@@ -12194,18 +13713,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 join5(homedir5(), "Documents", "Roblox", "Plugins");
+  return join6(homedir5(), "Documents", "Roblox", "Plugins");
 }
 function handleVariantConflict({ pluginsFolder, otherAssetName, replace, log = console.log, warn = console.warn }) {
-  const otherDest = join5(pluginsFolder, otherAssetName);
-  if (!existsSync5(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;
   }
@@ -12234,6 +13753,7 @@ var init_dist = __esm({
     init_opencloud_client();
     init_install_plugin_helpers();
     init_roblox_cookie_client();
+    init_studio_skills();
   }
 });
 
@@ -12243,13 +13763,13 @@ __export(install_plugin_exports, {
   installBundledPlugin: () => installBundledPlugin,
   installPlugin: () => installPlugin
 });
-import { copyFileSync as copyFileSync2, createWriteStream, existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync7, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname4, join as join6 } 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`));
@@ -12267,21 +13787,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);
@@ -12304,7 +13824,7 @@ function prepareInstall({
   warn
 }) {
   const pluginsFolder = getPluginsFolder();
-  if (!existsSync6(pluginsFolder)) {
+  if (!existsSync7(pluginsFolder)) {
     mkdirSync5(pluginsFolder, { recursive: true });
   }
   handleVariantConflict({
@@ -12317,23 +13837,23 @@ function prepareInstall({
   return pluginsFolder;
 }
 function bundledAssetPath() {
-  const currentDir = dirname4(fileURLToPath(import.meta.url));
+  const currentDir = dirname5(fileURLToPath(import.meta.url));
   const candidates = [
-    join6(currentDir, "..", "studio-plugin", ASSET_NAME),
-    join6(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
+    join7(currentDir, "..", "studio-plugin", ASSET_NAME),
+    join7(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
   ];
-  return candidates.find((candidate) => existsSync6(candidate)) ?? null;
+  return candidates.find((candidate) => existsSync7(candidate)) ?? null;
 }
 function packageVersion() {
-  const currentDir = dirname4(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync7(join6(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 = readFileSync7(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
+  const match = readFileSync8(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
   return match ? match[1] : null;
 }
 function assertBundledPluginVersion(source) {
@@ -12346,9 +13866,9 @@ function assertBundledPluginVersion(source) {
   }
 }
 function filesMatch(a, b) {
-  if (!existsSync6(b)) return false;
-  const aBytes = readFileSync7(a);
-  const bBytes = readFileSync7(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 = {}) {
@@ -12361,7 +13881,7 @@ async function installBundledPlugin(options = {}) {
   }
   assertBundledPluginVersion(source);
   const pluginsFolder = prepareInstall({ replaceVariant, log, warn });
-  const dest = join6(pluginsFolder, ASSET_NAME);
+  const dest = join7(pluginsFolder, ASSET_NAME);
   if (filesMatch(source, dest)) return;
   copyFileSync2(source, dest);
   log(`Installed ${ASSET_NAME} to ${dest}`);
@@ -12374,7 +13894,7 @@ async function installPlugin(options = {}) {
   const bundled = bundledAssetPath();
   if (bundled) {
     assertBundledPluginVersion(bundled);
-    const dest2 = join6(pluginsFolder, ASSET_NAME);
+    const dest2 = join7(pluginsFolder, ASSET_NAME);
     if (filesMatch(bundled, dest2)) {
       log(`${ASSET_NAME} already installed.`);
       return;
@@ -12389,7 +13909,7 @@ async function installPlugin(options = {}) {
   if (!asset) {
     throw new Error(`${ASSET_NAME} not found in release ${release.tag_name}`);
   }
-  const dest = join6(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}`);
@@ -12412,8 +13932,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 {
@@ -12422,9 +13942,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)}`
       );
     });
   }