@chrrxs/robloxstudio-mcp-inspector 2.22.2 → 2.22.4

package/dist/index.js

@@ -889,6 +889,7 @@ function requiredClosedLineRange(body, toolName) {
 }
 function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   const app = express();
+  const studioLifecycleCallable = !allowedTools || allowedTools.has("manage_instance");
   let mcpServerActive = false;
   let lastMCPActivity = 0;
   let mcpServerStartTime = 0;
@@ -968,8 +969,15 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     res.json({
       status: "ok",
       service: "robloxstudio-mcp",
+      serverName: serverConfig?.name ?? "robloxstudio-mcp",
       version: serverConfig?.version,
       serverVersion: serverConfig?.version,
+      capabilities: studioLifecycleCallable ? {
+        studioLifecycle: {
+          protocolVersion: 1,
+          endpoint: "/mcp/manage_instance"
+        }
+      } : {},
       pluginConnected: instances.length > 0,
       instanceCount: instances.length,
       instances: publicInstances,
@@ -3065,7 +3073,8 @@ var init_roblox_cookie_client = __esm({
 });
 
 // ../core/dist/managed-instance-registry.js
-import * as fs from "fs";
+import * as fs from "fs/promises";
+import { randomUUID } from "crypto";
 import * as os from "os";
 import * as path from "path";
 function defaultManagedInstanceRegistryDir() {
@@ -3080,8 +3089,8 @@ function defaultManagedInstanceRegistryDir() {
   }
   return path.join(os.homedir(), ".local", "state", "robloxstudio-mcp", "managed-instances", "v1");
 }
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+function delay(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function ymd(timestamp) {
   return new Date(timestamp).toISOString().slice(0, 10);
@@ -3096,92 +3105,131 @@ 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, TERMINAL_RECORD_RETENTION_MS, ManagedInstanceRegistry;
+function isLockOwner(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const owner = value;
+  return Number.isInteger(owner.pid) && owner.pid > 0 && typeof owner.token === "string" && owner.token.length > 0 && typeof owner.createdAt === "number";
+}
+function isProcessAlive(pid) {
+  if (pid === process.pid)
+    return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var REGISTRY_VERSION, LOCK_STALE_MS, LOCK_RETRY_MS, LOCK_TIMEOUT_MS, EVENT_RETENTION_DAYS, TERMINAL_RECORD_RETENTION_MS, DEFAULT_CONFIRMED_EXIT_MISSES, DEFAULT_CONFIRMED_EXIT_GRACE_MS, activeLockTokens, ManagedInstanceRegistry;
 var init_managed_instance_registry = __esm({
   "../core/dist/managed-instance-registry.js"() {
     "use strict";
     REGISTRY_VERSION = 1;
     LOCK_STALE_MS = 1e4;
     LOCK_RETRY_MS = 25;
-    LOCK_TIMEOUT_MS = 5e3;
+    LOCK_TIMEOUT_MS = 15e3;
     EVENT_RETENTION_DAYS = 2;
     TERMINAL_RECORD_RETENTION_MS = 24 * 60 * 60 * 1e3;
+    DEFAULT_CONFIRMED_EXIT_MISSES = 2;
+    DEFAULT_CONFIRMED_EXIT_GRACE_MS = 5e3;
+    activeLockTokens = /* @__PURE__ */ new Set();
     ManagedInstanceRegistry = class {
       dir;
       constructor(dir = defaultManagedInstanceRegistryDir()) {
         this.dir = dir;
       }
-      upsert(record) {
-        this.withLock(() => this.writeRecordUnlocked(record));
+      async upsert(record) {
+        await this.withLock(() => this.writeRecordUnlocked(record));
       }
-      attachInstanceId(recordId, instanceId) {
-        this.withLock(() => {
-          const record = this.readRecordUnlocked(recordId);
+      async attachInstanceId(recordId, instanceId) {
+        await this.withLock(async () => {
+          const record = await this.readRecordUnlocked(recordId);
           if (!record)
             return;
           record.instanceId = instanceId;
           record.attachedAt = Date.now();
-          this.writeRecordUnlocked(record);
+          await this.writeRecordUnlocked(record);
         });
       }
-      findOpenByInstanceId(instanceId, options) {
-        return this.withLock(() => {
-          this.sweepUnlocked(options);
-          return this.readOpenRecordsUnlocked().find((record) => record.instanceId === instanceId);
+      async findOpenByInstanceId(instanceId, options) {
+        return this.withLock(async () => {
+          await this.sweepUnlocked(options);
+          return (await this.readOpenRecordsUnlocked()).find((record) => record.instanceId === instanceId);
         });
       }
-      findAnyByInstanceId(instanceId) {
-        return this.withLock(() => this.readRecordsUnlocked().find((record) => record.instanceId === instanceId));
+      async findAnyByInstanceId(instanceId) {
+        return this.withLock(async () => (await this.readRecordsUnlocked()).find((record) => record.instanceId === instanceId));
       }
-      findAnyByRecordId(recordId, options) {
-        return this.withLock(() => {
-          this.sweepUnlocked(options);
-          return this.readRecordsUnlocked().find((record) => record.recordId === recordId);
+      async findAnyByRecordId(recordId, options) {
+        return this.withLock(async () => {
+          if (options)
+            await this.sweepUnlocked(options);
+          return (await this.readRecordsUnlocked()).find((record) => record.recordId === recordId);
         });
       }
-      listOpen(options) {
-        return this.withLock(() => {
-          this.sweepUnlocked(options);
+      async listOpen(options) {
+        return this.withLock(async () => {
+          await this.sweepUnlocked(options);
           return this.readOpenRecordsUnlocked();
         });
       }
-      listOpenUnchecked() {
+      async listOpenUnchecked() {
         return this.withLock(() => this.readOpenRecordsUnlocked());
       }
-      markClosed(recordId, closedAt = Date.now()) {
-        this.withLock(() => {
-          const record = this.readRecordUnlocked(recordId);
+      async markClosed(recordId, closedAt = Date.now()) {
+        await this.withLock(async () => {
+          const record = await this.readRecordUnlocked(recordId);
           if (!record)
             return;
           record.closedAt = closedAt;
-          this.writeRecordUnlocked(record);
+          await this.writeRecordUnlocked(record);
         });
       }
-      delete(recordId) {
-        this.withLock(() => this.deleteRecordUnlocked(recordId));
+      async delete(recordId) {
+        await this.withLock(() => this.deleteRecordUnlocked(recordId));
       }
-      sweep(options) {
-        this.withLock(() => this.sweepUnlocked(options));
+      async sweep(options) {
+        await this.withLock(() => this.sweepUnlocked(options));
       }
-      logEvent(event, now = Date.now()) {
-        this.withLock(() => this.appendEventUnlocked(event, now));
+      async logEvent(event, now = Date.now()) {
+        await this.withLock(() => this.appendEventUnlocked(event, now));
       }
-      withLock(fn) {
-        this.ensureDir();
+      async withLock(fn) {
+        await this.ensureDir();
         const lockDir = path.join(this.dir, ".lock");
         const deadline = Date.now() + LOCK_TIMEOUT_MS;
-        while (true) {
+        const owner = {
+          pid: process.pid,
+          token: randomUUID(),
+          createdAt: Date.now()
+        };
+        for (; ; ) {
           try {
-            fs.mkdirSync(lockDir);
+            await fs.mkdir(lockDir);
+            activeLockTokens.add(owner.token);
+            try {
+              await fs.writeFile(path.join(lockDir, "owner.json"), `${JSON.stringify(owner)}
+`, {
+                encoding: "utf8",
+                flag: "wx"
+              });
+            } catch (error) {
+              activeLockTokens.delete(owner.token);
+              await fs.rm(lockDir, { recursive: true, force: true });
+              throw error;
+            }
             break;
           } catch (error) {
             const code = error.code;
             if (code !== "EEXIST")
               throw error;
             try {
-              const stat = fs.statSync(lockDir);
-              if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-                fs.rmSync(lockDir, { recursive: true, force: true });
+              const stat2 = await fs.stat(lockDir);
+              const currentOwner = await this.readLockOwner(lockDir, stat2.isDirectory());
+              const ownerIsActive = currentOwner?.pid === process.pid ? activeLockTokens.has(currentOwner.token) : currentOwner ? isProcessAlive(currentOwner.pid) : void 0;
+              if (ownerIsActive === false || currentOwner === void 0 && Date.now() - stat2.mtimeMs > LOCK_STALE_MS) {
+                await fs.rm(lockDir, { recursive: true, force: true });
                 continue;
               }
             } catch {
@@ -3190,40 +3238,58 @@ var init_managed_instance_registry = __esm({
             if (Date.now() > deadline) {
               throw new Error(`Timed out waiting for managed instance registry lock: ${lockDir}`);
             }
-            sleepSync(LOCK_RETRY_MS);
+            await delay(LOCK_RETRY_MS);
           }
         }
         try {
-          return fn();
+          return await fn();
         } finally {
-          fs.rmSync(lockDir, { recursive: true, force: true });
+          try {
+            const stat2 = await fs.stat(lockDir);
+            const currentOwner = await this.readLockOwner(lockDir, stat2.isDirectory());
+            if (currentOwner?.pid === owner.pid && currentOwner.token === owner.token) {
+              await fs.rm(lockDir, { recursive: true, force: true });
+            }
+          } catch {
+          } finally {
+            activeLockTokens.delete(owner.token);
+          }
+        }
+      }
+      async readLockOwner(lockPath, isDirectory) {
+        try {
+          const contents = await fs.readFile(isDirectory ? path.join(lockPath, "owner.json") : lockPath, "utf8");
+          const parsed = JSON.parse(contents);
+          return isLockOwner(parsed) ? parsed : void 0;
+        } catch {
+          return void 0;
         }
       }
-      ensureDir() {
-        fs.mkdirSync(this.dir, { recursive: true });
+      async ensureDir() {
+        await fs.mkdir(this.dir, { recursive: true });
       }
       recordPath(recordId) {
         return path.join(this.dir, `${recordId}.json`);
       }
-      recordFilesUnlocked() {
-        return fs.readdirSync(this.dir).filter((name) => name.endsWith(".json")).map((name) => path.join(this.dir, name));
+      async recordFilesUnlocked() {
+        return (await fs.readdir(this.dir)).filter((name) => name.endsWith(".json")).map((name) => path.join(this.dir, name));
       }
-      readRecordUnlocked(recordId) {
+      async readRecordUnlocked(recordId) {
         try {
-          const parsed = JSON.parse(fs.readFileSync(this.recordPath(recordId), "utf8"));
+          const parsed = JSON.parse(await fs.readFile(this.recordPath(recordId), "utf8"));
           return isRecord(parsed) ? parsed : void 0;
         } catch {
           return void 0;
         }
       }
-      readOpenRecordsUnlocked() {
-        return this.readRecordsUnlocked().filter((record) => record.closedAt === void 0);
+      async readOpenRecordsUnlocked() {
+        return (await this.readRecordsUnlocked()).filter((record) => record.closedAt === void 0);
       }
-      readRecordsUnlocked() {
+      async readRecordsUnlocked() {
         const records = [];
-        for (const file of this.recordFilesUnlocked()) {
+        for (const file of await this.recordFilesUnlocked()) {
           try {
-            const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+            const parsed = JSON.parse(await fs.readFile(file, "utf8"));
             if (!isRecord(parsed))
               continue;
             records.push(parsed);
@@ -3232,48 +3298,48 @@ var init_managed_instance_registry = __esm({
         }
         return records;
       }
-      writeRecordUnlocked(record) {
-        this.ensureDir();
+      async writeRecordUnlocked(record) {
+        await this.ensureDir();
         const finalPath = this.recordPath(record.recordId);
         const tmpPath = path.join(this.dir, `${record.recordId}.${process.pid}.${Date.now()}.tmp`);
-        const fd = fs.openSync(tmpPath, "w");
+        const fd = await fs.open(tmpPath, "w");
         try {
-          fs.writeFileSync(fd, `${JSON.stringify(record, null, 2)}
+          await fd.writeFile(`${JSON.stringify(record, null, 2)}
 `, "utf8");
-          fs.fsyncSync(fd);
+          await fd.sync();
         } finally {
-          fs.closeSync(fd);
+          await fd.close();
         }
-        fs.renameSync(tmpPath, finalPath);
+        await fs.rename(tmpPath, finalPath);
       }
-      deleteRecordUnlocked(recordId) {
-        fs.rmSync(this.recordPath(recordId), { force: true });
+      async deleteRecordUnlocked(recordId) {
+        await fs.rm(this.recordPath(recordId), { force: true });
       }
-      appendEventUnlocked(event, now) {
+      async appendEventUnlocked(event, now) {
         const file = path.join(this.dir, `events-${ymd(now)}.jsonl`);
-        fs.appendFileSync(file, `${JSON.stringify({
+        await fs.appendFile(file, `${JSON.stringify({
           ts: new Date(now).toISOString(),
           ...event
         })}
 `, "utf8");
       }
-      cleanupOldEventLogsUnlocked(now) {
+      async cleanupOldEventLogsUnlocked(now) {
         const cutoff = ymd(now - EVENT_RETENTION_DAYS * 24 * 60 * 60 * 1e3);
-        for (const name of fs.readdirSync(this.dir)) {
+        for (const name of await fs.readdir(this.dir)) {
           const date = eventLogDate(name);
           if (!date || date >= cutoff)
             continue;
           try {
-            fs.rmSync(path.join(this.dir, name), { force: true });
+            await fs.rm(path.join(this.dir, name), { force: true });
           } catch {
           }
         }
       }
-      cleanupRecord(options, record) {
+      async cleanupRecord(options, record) {
         try {
-          options.cleanupRecord?.(record);
+          await options.cleanupRecord?.(record);
         } catch {
-          this.appendEventUnlocked({
+          await this.appendEventUnlocked({
             event: "registry_cleanup_failed",
             recordId: record.recordId,
             instanceId: record.instanceId,
@@ -3282,16 +3348,16 @@ var init_managed_instance_registry = __esm({
           }, options.now ?? Date.now());
         }
       }
-      sweepUnlocked(options) {
+      async sweepUnlocked(options) {
         const now = options.now ?? Date.now();
-        this.cleanupOldEventLogsUnlocked(now);
-        for (const file of this.recordFilesUnlocked()) {
+        await this.cleanupOldEventLogsUnlocked(now);
+        for (const file of await this.recordFilesUnlocked()) {
           let parsed;
           try {
-            parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+            parsed = JSON.parse(await fs.readFile(file, "utf8"));
           } catch {
-            fs.rmSync(file, { force: true });
-            this.appendEventUnlocked({
+            await fs.rm(file, { force: true });
+            await this.appendEventUnlocked({
               event: "registry_pruned_malformed_record",
               reason: "parse_error",
               action: "deleted_record"
@@ -3299,8 +3365,8 @@ var init_managed_instance_registry = __esm({
             continue;
           }
           if (!parsed || typeof parsed !== "object") {
-            fs.rmSync(file, { force: true });
-            this.appendEventUnlocked({
+            await fs.rm(file, { force: true });
+            await this.appendEventUnlocked({
               event: "registry_pruned_malformed_record",
               reason: "invalid_shape",
               action: "deleted_record"
@@ -3311,8 +3377,8 @@ var init_managed_instance_registry = __esm({
           if (typeof version === "number" && version > REGISTRY_VERSION)
             continue;
           if (!isRecord(parsed)) {
-            fs.rmSync(file, { force: true });
-            this.appendEventUnlocked({
+            await fs.rm(file, { force: true });
+            await this.appendEventUnlocked({
               event: "registry_pruned_malformed_record",
               reason: "invalid_shape",
               action: "deleted_record"
@@ -3322,8 +3388,8 @@ var init_managed_instance_registry = __esm({
           const terminalAt = parsed.closedAt ?? parsed.exitedAt;
           if (terminalAt !== void 0) {
             if (now - terminalAt > TERMINAL_RECORD_RETENTION_MS) {
-              fs.rmSync(file, { force: true });
-              this.appendEventUnlocked({
+              await fs.rm(file, { force: true });
+              await this.appendEventUnlocked({
                 event: "registry_pruned_terminal_record",
                 recordId: parsed.recordId,
                 instanceId: parsed.instanceId,
@@ -3335,13 +3401,13 @@ var init_managed_instance_registry = __esm({
             continue;
           }
           if (parsed.bootId !== options.currentBootId) {
-            this.cleanupRecord(options, parsed);
+            await this.cleanupRecord(options, parsed);
             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({
+            await this.writeRecordUnlocked(parsed);
+            await this.appendEventUnlocked({
               event: "registry_marked_previous_boot_exited",
               recordId: parsed.recordId,
               instanceId: parsed.instanceId,
@@ -3351,22 +3417,56 @@ var init_managed_instance_registry = __esm({
             }, now);
             continue;
           }
-          if (options.isProcessRunning && (parsed.nativeProcessId || parsed.spawnPid) && !options.isProcessRunning(parsed)) {
-            this.cleanupRecord(options, parsed);
-            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_marked_process_exited",
-              recordId: parsed.recordId,
-              instanceId: parsed.instanceId,
-              source: parsed.source,
-              reason: "pid_not_running",
-              action: "marked_exited_and_cleaned_baseplate"
-            }, now);
+          if (!options.observeProcess || !(parsed.nativeProcessId || parsed.spawnPid))
+            continue;
+          const observation = await options.observeProcess(parsed);
+          if (observation.status === "unknown") {
+            parsed.processObservationStatus = "unknown";
+            parsed.lastProcessObservationAt = observation.observedAt;
+            parsed.lastProcessObservationError = observation.error;
+            parsed.consecutiveConfirmedMisses = 0;
+            parsed.firstConfirmedMissAt = void 0;
+            await this.writeRecordUnlocked(parsed);
+            continue;
+          }
+          const previousObservationAt = parsed.lastProcessObservationAt;
+          parsed.lastSuccessfulProcessObservationAt = observation.observedAt;
+          parsed.lastProcessObservationAt = observation.observedAt;
+          parsed.lastProcessObservationError = void 0;
+          if (observation.status === "running") {
+            parsed.processObservationStatus = "running";
+            parsed.consecutiveConfirmedMisses = 0;
+            parsed.firstConfirmedMissAt = void 0;
+            await this.writeRecordUnlocked(parsed);
+            continue;
           }
+          const isNewObservation = previousObservationAt !== observation.observedAt;
+          parsed.processObservationStatus = "not_running";
+          if (previousObservationAt !== observation.observedAt) {
+            parsed.consecutiveConfirmedMisses = (parsed.consecutiveConfirmedMisses ?? 0) + 1;
+            parsed.firstConfirmedMissAt ??= observation.observedAt;
+          }
+          const requiredMisses = options.confirmedExitMisses ?? DEFAULT_CONFIRMED_EXIT_MISSES;
+          const graceMs = options.confirmedExitGraceMs ?? DEFAULT_CONFIRMED_EXIT_GRACE_MS;
+          const confirmedAbsent = observation.reason === "identity_mismatch" || isNewObservation && (parsed.consecutiveConfirmedMisses ?? 0) >= requiredMisses && observation.observedAt - (parsed.firstConfirmedMissAt ?? observation.observedAt) >= graceMs;
+          if (!confirmedAbsent) {
+            await this.writeRecordUnlocked(parsed);
+            continue;
+          }
+          await this.cleanupRecord(options, parsed);
+          parsed.state = parsed.state === "failed" ? "failed" : "exited";
+          parsed.exitedAt = observation.observedAt;
+          parsed.closedAt = observation.observedAt;
+          parsed.failureReason = observation.reason === "identity_mismatch" ? "Studio process identity changed; the retained PID was not reused." : parsed.instanceId ? "Studio process exited." : "Studio process exited before the MCP plugin connected.";
+          await this.writeRecordUnlocked(parsed);
+          await this.appendEventUnlocked({
+            event: "registry_marked_process_exited",
+            recordId: parsed.recordId,
+            instanceId: parsed.instanceId,
+            source: parsed.source,
+            reason: observation.reason === "identity_mismatch" ? "identity_mismatch" : "pid_not_running",
+            action: "marked_exited_and_cleaned_baseplate"
+          }, now);
         }
       }
     };
@@ -3374,11 +3474,12 @@ var init_managed_instance_registry = __esm({
 });
 
 // ../core/dist/studio-instance-manager.js
-import { execFileSync, spawn } from "child_process";
-import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, realpathSync, rmSync as rmSync2, statSync as statSync2 } from "fs";
-import { randomUUID } from "crypto";
+import { execFile, execFileSync, spawn } from "child_process";
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, realpathSync, rmSync, statSync } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
 import * as os2 from "os";
 import * as path2 from "path";
+import { promisify } from "util";
 function run(command, args, options = {}) {
   return execFileSync(command, args, {
     encoding: "utf8",
@@ -3386,17 +3487,29 @@ function run(command, args, options = {}) {
     ...options
   }).trim();
 }
+async function runAsync(command, args, options = {}) {
+  const result = await execFileAsync(command, args, {
+    encoding: "utf8",
+    maxBuffer: 4 * 1024 * 1024,
+    timeout: 15e3,
+    killSignal: "SIGKILL",
+    ...options
+  });
+  return `${result.stdout}`.trim();
+}
 function isWsl() {
   if (process.platform !== "linux")
     return false;
+  if (!process.env.WSL_INTEROP && !process.env.WSL_DISTRO_NAME)
+    return false;
   try {
-    return /microsoft|wsl/i.test(readFileSync3("/proc/version", "utf8"));
+    return /microsoft|wsl/i.test(readFileSync2("/proc/version", "utf8"));
   } catch {
     return false;
   }
 }
-function powershell(script) {
-  return run("powershell.exe", ["-NoProfile", "-Command", script], {
+async function powershellAsync(script) {
+  return runAsync("powershell.exe", ["-NoProfile", "-Command", script], {
     cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
   });
 }
@@ -3413,19 +3526,96 @@ function windowsLocalAppData() {
     return void 0;
   }
 }
+async function windowsLocalAppDataAsync() {
+  if (process.platform === "win32")
+    return process.env.LOCALAPPDATA;
+  if (!isWsl())
+    return void 0;
+  try {
+    return await runAsync("cmd.exe", ["/c", "echo %LOCALAPPDATA%"], {
+      cwd: existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
+    });
+  } catch {
+    return void 0;
+  }
+}
 function toWslPath(windowsPath) {
   if (!isWsl())
     return windowsPath;
   return run("wslpath", ["-u", windowsPath]);
 }
-function toStudioLaunchArg(arg) {
+async function toWslPathAsync(windowsPath) {
+  if (!isWsl())
+    return windowsPath;
+  return runAsync("wslpath", ["-u", windowsPath]);
+}
+async function toStudioLaunchArgAsync(arg) {
   if (!isWsl() || !path2.isAbsolute(arg) || !existsSync2(arg))
     return arg;
-  return run("wslpath", ["-w", arg]);
+  return runAsync("wslpath", ["-w", arg]);
 }
 function powershellStringLiteral(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
+function parseStudioProcessEnvironmentPatch(value) {
+  if (value === void 0)
+    return void 0;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("process_environment must be an object when provided.");
+  }
+  const raw = value;
+  const unsupported = Object.keys(raw).filter((key) => key !== "set" && key !== "remove");
+  if (unsupported.length > 0) {
+    throw new Error(`process_environment contains unsupported field(s): ${unsupported.join(", ")}.`);
+  }
+  let set;
+  if (raw.set !== void 0) {
+    if (raw.set === null || typeof raw.set !== "object" || Array.isArray(raw.set)) {
+      throw new Error("process_environment.set must be an object mapping names to string values.");
+    }
+    set = {};
+    for (const [name, setting] of Object.entries(raw.set)) {
+      if (!ENVIRONMENT_VARIABLE_NAME.test(name)) {
+        throw new Error(`Invalid process environment variable name "${name}".`);
+      }
+      if (typeof setting !== "string") {
+        throw new Error(`process_environment.set.${name} must be a string.`);
+      }
+      if (setting.includes("\0")) {
+        throw new Error(`process_environment.set.${name} must not contain a null character.`);
+      }
+      set[name] = setting;
+    }
+  }
+  let remove;
+  if (raw.remove !== void 0) {
+    if (!Array.isArray(raw.remove) || raw.remove.some((name) => typeof name !== "string")) {
+      throw new Error("process_environment.remove must be an array of environment variable names.");
+    }
+    remove = [...new Set(raw.remove)];
+    for (const name of remove) {
+      if (!ENVIRONMENT_VARIABLE_NAME.test(name)) {
+        throw new Error(`Invalid process environment variable name "${name}".`);
+      }
+    }
+  }
+  return { set, remove };
+}
+function patchedProcessEnvironment(patch) {
+  const environment = { ...process.env };
+  for (const name of patch.remove ?? [])
+    delete environment[name];
+  for (const [name, value] of Object.entries(patch.set ?? {}))
+    environment[name] = value;
+  return environment;
+}
+function powershellEnvironmentPatchStatements(patch) {
+  const target = "[EnvironmentVariableTarget]::Process";
+  return [
+    ...(patch.remove ?? []).map((name) => `[Environment]::SetEnvironmentVariable(${powershellStringLiteral(name)}, $null, ${target})`),
+    ...Object.entries(patch.set ?? {}).map(([name, value]) => `[Environment]::SetEnvironmentVariable(${powershellStringLiteral(name)}, ${powershellStringLiteral(value)}, ${target})`)
+  ];
+}
 function quoteWindowsCommandLineArg(value) {
   if (value.length > 0 && !/[\s"]/u.test(value))
     return value;
@@ -3446,16 +3636,17 @@ function quoteWindowsCommandLineArg(value) {
   }
   return `${quoted}${"\\".repeat(backslashes * 2)}"`;
 }
-function buildWindowsStudioStartScript(exe, args) {
-  const windowsExe = toStudioLaunchArg(exe);
+function buildWindowsStudioStartScriptFromConvertedExe(windowsExe, args, processEnvironment) {
+  const environmentPatch = parseStudioProcessEnvironmentPatch(processEnvironment);
   const commandLine = args.map(quoteWindowsCommandLineArg).join(" ");
   return [
+    ...environmentPatch ? powershellEnvironmentPatchStatements(environmentPatch) : [],
     "$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
+    // handles keep the PowerShell invocation 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",
@@ -3463,9 +3654,10 @@ function buildWindowsStudioStartScript(exe, args) {
     '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`);
+async function spawnWindowsStudioFromWsl(exe, args, processEnvironment) {
+  const windowsExe = await toStudioLaunchArgAsync(exe);
+  const script = buildWindowsStudioStartScriptFromConvertedExe(windowsExe, args, processEnvironment);
+  const output = await powershellAsync(`${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;
@@ -3507,7 +3699,7 @@ function resolveBaseplateTemplatePath() {
   }
   throw new Error(`Baseplate template not found. Expected ${BASEPLATE_TEMPLATE_NAME} in one of: ${candidates.join(", ")}`);
 }
-function isProcessAlive(pid) {
+function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -3518,7 +3710,7 @@ function isProcessAlive(pid) {
 function sweepStaleBaseplateFiles() {
   let entries;
   try {
-    entries = readdirSync2(BASEPLATE_TEMP_DIR);
+    entries = readdirSync(BASEPLATE_TEMP_DIR);
   } catch {
     return;
   }
@@ -3527,18 +3719,18 @@ function sweepStaleBaseplateFiles() {
     const match = BASEPLATE_TEMP_SWEEP_NAME.exec(entry);
     if (!match)
       continue;
-    if (Number(match[1]) !== process.pid && isProcessAlive(Number(match[1])))
+    if (Number(match[1]) !== process.pid && isProcessAlive2(Number(match[1])))
       continue;
     const file = path2.join(BASEPLATE_TEMP_DIR, entry);
     try {
-      if (statSync2(file).mtimeMs < cutoff)
-        rmSync2(file, { force: true });
+      if (statSync(file).mtimeMs < cutoff)
+        rmSync(file, { force: true });
     } catch {
     }
   }
 }
 function createBaseplatePlaceFile() {
-  mkdirSync3(BASEPLATE_TEMP_DIR, { recursive: true });
+  mkdirSync2(BASEPLATE_TEMP_DIR, { recursive: true });
   sweepStaleBaseplateFiles();
   const file = path2.join(BASEPLATE_TEMP_DIR, `Baseplate-${process.pid}-${Date.now()}.rbxl`);
   copyFileSync(resolveBaseplateTemplatePath(), file);
@@ -3555,7 +3747,7 @@ function cleanupManagedBaseplateFiles(record) {
     return;
   for (const file of [record.localPlaceFile, `${record.localPlaceFile}.lock`]) {
     try {
-      rmSync2(file, { force: true });
+      rmSync(file, { force: true });
     } catch {
     }
   }
@@ -3582,54 +3774,83 @@ function resolveStudioExe() {
   if (!existsSync2(root)) {
     throw new Error(`Roblox Studio Versions folder not found: ${root}. Set ROBLOX_STUDIO_EXE.`);
   }
-  const candidates = readdirSync2(root).filter((name) => name.startsWith("version-")).map((name) => path2.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync2(candidate)).sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs);
+  const candidates = readdirSync(root).filter((name) => name.startsWith("version-")).map((name) => path2.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync2(candidate)).sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
   if (candidates.length === 0) {
     throw new Error(`RobloxStudioBeta.exe not found under ${root}. Set ROBLOX_STUDIO_EXE.`);
   }
   return candidates[0];
 }
-function listStudioProcesses() {
+async function resolveStudioExeAsync() {
+  if (process.env.ROBLOX_STUDIO_EXE)
+    return process.env.ROBLOX_STUDIO_EXE;
   if (process.platform === "darwin") {
-    let out2 = "";
-    try {
-      out2 = run("pgrep", ["-fl", "RobloxStudio"]);
-    } catch {
-      return [];
-    }
-    return out2.split("\n").filter(Boolean).map((line) => {
-      const [pid, ...rest] = line.trim().split(/\s+/);
-      return { Id: Number(pid), Name: "RobloxStudio", Path: rest.join(" "), MainWindowTitle: "" };
-    }).filter((proc) => Number.isFinite(proc.Id));
+    return "/Applications/RobloxStudio.app/Contents/MacOS/RobloxStudio";
   }
-  if (process.platform !== "win32" && !isWsl())
-    return [];
-  let out = "";
+  if (process.platform !== "win32" && !isWsl()) {
+    throw new Error("Roblox Studio executable auto-discovery is only supported on Windows, WSL, and macOS. Set ROBLOX_STUDIO_EXE.");
+  }
+  const localAppData = await windowsLocalAppDataAsync();
+  const root = localAppData ? path2.join(await toWslPathAsync(localAppData), "Roblox", "Versions") : path2.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
+  if (!existsSync2(root)) {
+    throw new Error(`Roblox Studio Versions folder not found: ${root}. Set ROBLOX_STUDIO_EXE.`);
+  }
+  const candidates = readdirSync(root).filter((name) => name.startsWith("version-")).map((name) => path2.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync2(candidate)).sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
+  if (candidates.length === 0) {
+    throw new Error(`RobloxStudioBeta.exe not found under ${root}. Set ROBLOX_STUDIO_EXE.`);
+  }
+  return candidates[0];
+}
+async function observeStudioProcesses() {
+  const observedAt = Date.now();
   try {
-    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 [];
+    if (process.platform === "darwin") {
+      let out2 = "";
+      try {
+        out2 = await runAsync("pgrep", ["-fl", "RobloxStudio"]);
+      } catch (error) {
+        const code = error.code;
+        if (Number(code) === 1)
+          return { status: "ok", observedAt, processes: [] };
+        throw error;
+      }
+      const processes = out2.split("\n").filter(Boolean).map((line) => {
+        const [pid, ...rest] = line.trim().split(/\s+/);
+        return { Id: Number(pid), Name: "RobloxStudio", Path: rest.join(" "), MainWindowTitle: "" };
+      }).filter((proc) => Number.isFinite(proc.Id));
+      return { status: "ok", observedAt, processes };
+    }
+    if (process.platform !== "win32" && !isWsl()) {
+      return { status: "ok", observedAt, processes: [] };
+    }
+    const out = await powershellAsync("Get-Process RobloxStudioBeta -ErrorAction SilentlyContinue | ForEach-Object { [PSCustomObject]@{ Id = $_.Id; Name = $_.Name; Path = $_.Path; MainWindowTitle = $_.MainWindowTitle; StartTimeUtcFileTime = $_.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() } } | ConvertTo-Json -Compress");
+    if (!out)
+      return { status: "ok", observedAt, processes: [] };
+    const parsed = JSON.parse(out);
+    return { status: "ok", observedAt, processes: Array.isArray(parsed) ? parsed : [parsed] };
+  } catch (error) {
+    return {
+      status: "error",
+      observedAt,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
-  if (!out)
-    return [];
-  const parsed = JSON.parse(out);
-  return Array.isArray(parsed) ? parsed : [parsed];
 }
-function currentBootId() {
+async function currentBootIdAsync() {
   if (process.platform === "linux") {
     try {
-      return readFileSync3("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      return readFileSync2("/proc/sys/kernel/random/boot_id", "utf8").trim();
     } catch {
     }
   }
   if (process.platform === "win32" || isWsl()) {
     try {
-      return powershell('(Get-CimInstance Win32_OperatingSystem).LastBootUpTime.ToUniversalTime().ToString("o")');
+      return await powershellAsync('(Get-CimInstance Win32_OperatingSystem).LastBootUpTime.ToUniversalTime().ToString("o")');
     } catch {
     }
   }
   if (process.platform === "darwin") {
     try {
-      return run("sysctl", ["-n", "kern.boottime"]);
+      return await runAsync("sysctl", ["-n", "kern.boottime"]);
     } catch {
     }
   }
@@ -3668,13 +3889,13 @@ function buildStudioLaunchArgs(options) {
       ];
   }
 }
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function basenameAny(filePath) {
   return path2.basename(filePath.replace(/\\/g, "/"));
 }
-var BASEPLATE_TEMP_DIR, BASEPLATE_TEMP_NAME, BASEPLATE_TEMPLATE_NAME, STALE_BASEPLATE_MAX_AGE_MS, BASEPLATE_TEMP_SWEEP_NAME, StudioInstanceManager;
+var BASEPLATE_TEMP_DIR, BASEPLATE_TEMP_NAME, BASEPLATE_TEMPLATE_NAME, execFileAsync, ENVIRONMENT_VARIABLE_NAME, STALE_BASEPLATE_MAX_AGE_MS, BASEPLATE_TEMP_SWEEP_NAME, StudioInstanceManager;
 var init_studio_instance_manager = __esm({
   "../core/dist/studio-instance-manager.js"() {
     "use strict";
@@ -3682,26 +3903,39 @@ var init_studio_instance_manager = __esm({
     BASEPLATE_TEMP_DIR = path2.join(os2.tmpdir(), "robloxstudio-mcp-baseplates");
     BASEPLATE_TEMP_NAME = /^Baseplate-\d+-\d+\.rbxl$/;
     BASEPLATE_TEMPLATE_NAME = "Baseplate.rbxl";
+    execFileAsync = promisify(execFile);
+    ENVIRONMENT_VARIABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/u;
     STALE_BASEPLATE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
     BASEPLATE_TEMP_SWEEP_NAME = /^Baseplate-(\d+)-\d+\.rbxl(\.lock)?$/;
     StudioInstanceManager = class {
       managedByInstanceId = /* @__PURE__ */ new Map();
       pending = /* @__PURE__ */ new Set();
-      monitors = /* @__PURE__ */ new Map();
       connectionTimers = /* @__PURE__ */ new Map();
       registry;
       processAdapter;
+      confirmedExitMisses;
+      confirmedExitGraceMs;
+      snapshotCacheMs;
+      coordinatorTimer;
+      coordinatorRefresh;
+      cachedSnapshot;
+      snapshotInFlight;
+      launchQueue = Promise.resolve();
       constructor(options = {}) {
         this.registry = options.registry ?? new ManagedInstanceRegistry(options.registryDir);
         this.processAdapter = options.processAdapter ?? {};
+        this.confirmedExitMisses = options.confirmedExitMisses ?? 2;
+        this.confirmedExitGraceMs = options.confirmedExitGraceMs ?? 5e3;
+        this.snapshotCacheMs = options.snapshotCacheMs ?? 0;
       }
-      list() {
-        this.sweepRegistry();
+      async list() {
+        const snapshot = await this.getProcessSnapshot();
+        await this.sweepRegistry(snapshot);
         for (const record of [...this.managedByInstanceId.values(), ...this.pending]) {
-          this.refresh(record);
+          await this.refresh(record, snapshot);
         }
         const records = [...this.managedByInstanceId.values(), ...this.pending];
-        for (const registryRecord of this.registry.listOpen(this.registrySweepOptions())) {
+        for (const registryRecord of await this.registry.listOpenUnchecked()) {
           const record = this.fromRegistryRecord(registryRecord);
           if (records.some((existing) => record.recordId && existing.recordId === record.recordId || record.instanceId && existing.instanceId === record.instanceId)) {
             continue;
@@ -3710,27 +3944,30 @@ var init_studio_instance_manager = __esm({
         }
         return records.filter((record) => record.closedAt === void 0).filter((instance, index, all) => all.indexOf(instance) === index);
       }
-      get(instanceId) {
-        this.sweepRegistry();
+      async get(instanceId) {
+        const snapshot = await this.getProcessSnapshot();
+        await this.sweepRegistry(snapshot);
         const memoryRecord = this.managedByInstanceId.get(instanceId);
         if (memoryRecord)
-          return this.refresh(memoryRecord);
-        const registryRecord = this.registry.findAnyByInstanceId(instanceId);
-        return registryRecord ? this.refresh(this.fromRegistryRecord(registryRecord)) : void 0;
+          return this.refresh(memoryRecord, snapshot);
+        const registryRecord = await this.registry.findAnyByInstanceId(instanceId);
+        return registryRecord ? this.refresh(this.fromRegistryRecord(registryRecord), snapshot) : void 0;
       }
-      getByLaunchId(launchId) {
-        this.sweepRegistry();
+      async getByLaunchId(launchId) {
+        const snapshot = await this.getProcessSnapshot();
+        await this.sweepRegistry(snapshot);
         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;
+          return this.refresh(memoryRecord, snapshot);
+        const registryRecord = await this.registry.findAnyByRecordId(launchId);
+        return registryRecord ? this.refresh(this.fromRegistryRecord(registryRecord), snapshot) : void 0;
       }
-      pendingLaunches() {
+      async pendingLaunches() {
         const now = Date.now();
+        const bootId = await this.getCurrentBootId();
         const records = [...this.pending];
-        for (const registryRecord of this.registry.listOpenUnchecked()) {
-          if (registryRecord.bootId !== this.getCurrentBootId())
+        for (const registryRecord of await this.registry.listOpenUnchecked()) {
+          if (registryRecord.bootId !== bootId)
             continue;
           if (records.some((record) => record.recordId === registryRecord.recordId))
             continue;
@@ -3738,8 +3975,9 @@ var init_studio_instance_manager = __esm({
         }
         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);
+      async attachInstanceId(record, instanceId) {
+        const snapshot = await this.getProcessSnapshot(true);
+        await this.reconcileFromPositiveEvidence(record, snapshot);
         if (record.closedAt !== void 0 || record.state === "failed" || record.state === "exited")
           return;
         if (record.instanceId && record.instanceId !== instanceId)
@@ -3750,54 +3988,71 @@ var init_studio_instance_manager = __esm({
         this.clearConnectionTimer(record);
         this.pending.delete(record);
         this.managedByInstanceId.set(instanceId, record);
-        this.persist(record);
+        await this.persist(record);
       }
-      markFailed(record, reason) {
-        this.refresh(record);
+      async markFailed(record, reason) {
         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);
+        await this.persist(record);
         return record;
       }
-      refresh(record) {
+      async refresh(record, providedSnapshot) {
+        if (record.closedAt !== void 0)
+          return record;
+        const snapshot = providedSnapshot ?? await this.getProcessSnapshot();
+        await this.applyProcessObservation(record, this.observeRecord(record, snapshot));
         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);
+          await this.persist(record);
         }
         return record;
       }
       async launch(options) {
-        this.sweepRegistry();
+        const previous = this.launchQueue;
+        let release;
+        this.launchQueue = new Promise((resolve5) => {
+          release = resolve5;
+        });
+        await previous;
+        try {
+          return await this.launchSerialized(options);
+        } finally {
+          release();
+        }
+      }
+      async launchSerialized(options) {
+        const initialSnapshot = await this.getProcessSnapshot(true);
+        await this.sweepRegistry(initialSnapshot);
+        const processEnvironment = parseStudioProcessEnvironmentPatch(options.processEnvironment);
+        if (options.studioExecutable !== void 0 && (typeof options.studioExecutable !== "string" || options.studioExecutable.length === 0 || options.studioExecutable.includes("\0"))) {
+          throw new Error("studio_executable must be a non-empty string without null characters.");
+        }
         const preparedOptions = prepareStudioLaunchOptions(options);
-        const bootId = this.getCurrentBootId();
-        const before = new Set(this.listStudioProcesses().map((proc2) => proc2.Id));
-        const exe = this.processAdapter.resolveStudioExe?.() ?? resolveStudioExe();
-        const args = buildStudioLaunchArgs(preparedOptions).map(toStudioLaunchArg);
+        const bootId = await this.getCurrentBootId();
+        const before = new Set(initialSnapshot.status === "ok" ? initialSnapshot.processes.map((proc2) => proc2.Id) : []);
+        const exe = preparedOptions.studioExecutable ?? (this.processAdapter.resolveStudioExe ? await this.processAdapter.resolveStudioExe() : await resolveStudioExeAsync());
+        const args = await Promise.all(buildStudioLaunchArgs(preparedOptions).map(toStudioLaunchArgAsync));
         const spawnOptions = {
           cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd(),
           detached: true,
-          stdio: "ignore"
+          stdio: "ignore",
+          ...processEnvironment ? { env: patchedProcessEnvironment(processEnvironment) } : {}
         };
         let proc;
         try {
           if (this.processAdapter.spawnStudio) {
-            proc = this.processAdapter.spawnStudio(exe, args, spawnOptions);
+            proc = await this.processAdapter.spawnStudio(exe, args, spawnOptions);
           } else if (isWsl()) {
-            proc = spawnWindowsStudioFromWsl(exe, args);
+            proc = await spawnWindowsStudioFromWsl(exe, args, processEnvironment);
           } else {
             const child = spawn(exe, args, spawnOptions);
             proc = {
@@ -3816,8 +4071,9 @@ var init_studio_instance_manager = __esm({
           cleanupManagedBaseplateFiles({ source: preparedOptions.source, localPlaceFile: preparedOptions.localPlaceFile });
           throw error;
         }
+        const launchedAt = Date.now();
         const record = {
-          recordId: randomUUID(),
+          recordId: randomUUID2(),
           source: options.source,
           nativeProcessId: proc.nativePid,
           nativeProcessStartedAt: proc.nativeStartedAt,
@@ -3828,23 +4084,27 @@ var init_studio_instance_manager = __esm({
           universeId: preparedOptions.universeId,
           placeVersion: preparedOptions.placeVersion,
           localPlaceFile: preparedOptions.localPlaceFile,
-          launchedAt: Date.now(),
-          connectionDeadlineAt: Date.now() + (options.connectionTimeoutMs ?? 12e4),
+          launchedAt,
+          connectionDeadlineAt: launchedAt + (options.connectionTimeoutMs ?? 12e4),
           state: "launching",
           ownerPid: process.pid,
           bootId,
-          deleteLocalPlaceFileOnClose: options.source === "baseplate"
+          deleteLocalPlaceFileOnClose: options.source === "baseplate",
+          processObservationStatus: "running",
+          lastProcessObservationAt: launchedAt,
+          lastSuccessfulProcessObservationAt: launchedAt,
+          consecutiveConfirmedMisses: 0
         };
         this.pending.add(record);
         try {
-          this.persist(record);
+          await this.persist(record);
         } catch (error) {
           this.pending.delete(record);
           const processId = record.nativeProcessId ?? record.spawnPid;
           let stopError;
           if (processId) {
             try {
-              this.closeProcess(processId);
+              await this.closeProcess(processId);
             } catch (caught) {
               stopError = caught;
             }
@@ -3856,38 +4116,40 @@ var init_studio_instance_manager = __esm({
         }
         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.");
+          this.runInBackground("persisting a Studio process exit", 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}`);
+          this.runInBackground("persisting a Studio process launch failure", 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));
+          const snapshot = await this.getProcessSnapshot(true);
+          const created = snapshot.status === "ok" ? snapshot.processes.find((candidate) => !before.has(candidate.Id)) : void 0;
           if (created) {
             record.nativeProcessId = created.Id;
             record.nativeProcessStartedAt = created.StartTimeUtcFileTime;
-            this.persist(record);
+            await this.persist(record);
             break;
           }
-          await delay(250);
+          await delay2(250);
         }
         if (record.nativeProcessId === void 0 && process.platform !== "win32" && !isWsl()) {
           record.nativeProcessId = proc.pid;
-          this.persist(record);
+          await this.persist(record);
         }
         if (record.nativeProcessId !== void 0 && record.nativeProcessStartedAt === void 0) {
-          const nativeProcess = this.findProcessById(record.nativeProcessId);
+          const snapshot = await this.getProcessSnapshot(true);
+          const nativeProcess = snapshot.status === "ok" ? snapshot.processes.find((candidate) => candidate.Id === record.nativeProcessId) : void 0;
           if (nativeProcess?.StartTimeUtcFileTime !== void 0) {
             record.nativeProcessStartedAt = nativeProcess.StartTimeUtcFileTime;
-            this.persist(record);
+            await this.persist(record);
           }
         }
-        this.startMonitor(record);
+        this.startCoordinator(record);
         return record;
       }
-      closeByLaunchId(launchId) {
-        const record = this.getByLaunchId(launchId);
+      async closeByLaunchId(launchId) {
+        const record = await this.getByLaunchId(launchId);
         if (!record)
           return { status: "not_found", launchId };
         if (record.closedAt !== void 0) {
@@ -3895,19 +4157,19 @@ var init_studio_instance_manager = __esm({
         }
         return this.close(record);
       }
-      closeByInstanceId(instanceId) {
-        this.sweepRegistry();
+      async closeByInstanceId(instanceId) {
+        const snapshot = await this.getProcessSnapshot(true);
+        await this.sweepRegistry(snapshot);
         const memoryRecord = this.managedByInstanceId.get(instanceId);
         if (memoryRecord)
           return this.close(memoryRecord);
-        const registryRecord = this.registry.findAnyByInstanceId(instanceId);
+        const registryRecord = await this.registry.findAnyByInstanceId(instanceId);
         if (!registryRecord) {
-          this.sweepRegistry();
           return { status: "not_found", instanceId };
         }
         if (registryRecord.closedAt !== void 0) {
           this.cleanupManagedRecord(registryRecord);
-          this.registry.logEvent({
+          await this.registry.logEvent({
             event: "registry_close_already_stopped",
             recordId: registryRecord.recordId,
             instanceId: registryRecord.instanceId,
@@ -3919,9 +4181,7 @@ var init_studio_instance_manager = __esm({
         }
         return this.close(this.fromRegistryRecord(registryRecord));
       }
-      close(record) {
-        this.stopMonitor(record);
-        this.refresh(record);
+      async close(record) {
         if (record.closedAt !== void 0) {
           return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
         }
@@ -3929,36 +4189,33 @@ var init_studio_instance_manager = __esm({
         if (!processId) {
           throw new Error(`Cannot close ${record.instanceId ?? "Studio launch"} because its process id was not detected.`);
         }
-        const studioProcess = this.findProcessById(processId);
-        if (!studioProcess) {
+        const snapshot = await this.getProcessSnapshot(true);
+        const observation = this.observeRecord(record, snapshot);
+        if (observation.status === "unknown") {
+          await this.applyProcessObservation(record, observation);
+          throw new Error(`Cannot verify the managed Studio process because process observation failed: ${observation.error}`);
+        }
+        if (observation.status === "not_running") {
           this.cleanupManagedRecord(record);
-          this.markProcessExited(record, void 0, record.failureReason);
-          this.registry.logEvent({
+          await this.markProcessExited(record, void 0, observation.reason === "identity_mismatch" ? "Studio process identity changed; the retained PID was not reused." : record.failureReason);
+          await this.registry.logEvent({
             event: "registry_close_already_stopped",
             recordId: record.recordId,
             instanceId: record.instanceId,
             source: record.source,
-            reason: "pid_not_running",
+            reason: observation.reason === "identity_mismatch" ? "identity_mismatch" : "pid_not_running",
             action: "marked_closed_and_cleaned_baseplate"
           });
           return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
         }
-        if (!this.verifyProcessForRecord(record, studioProcess)) {
-          this.registry.logEvent({
-            event: "registry_process_verification_failed",
-            recordId: record.recordId,
-            instanceId: record.instanceId,
-            source: record.source,
-            reason: "identity_mismatch"
-          });
-          throw new Error("Managed Studio process identity could not be verified.");
-        }
         try {
-          this.closeProcess(processId);
+          await this.closeProcess(processId);
         } catch (error) {
-          if (this.findProcessById(processId))
+          const retry = await this.getProcessSnapshot(true);
+          const retryObservation = this.observeRecord(record, retry);
+          if (retryObservation.status === "running" || retryObservation.status === "unknown")
             throw error;
-          this.registry.logEvent({
+          await this.registry.logEvent({
             event: "registry_close_already_stopped",
             recordId: record.recordId,
             instanceId: record.instanceId,
@@ -3967,7 +4224,7 @@ var init_studio_instance_manager = __esm({
             action: "marked_closed_and_cleaned_baseplate"
           });
           this.cleanupManagedRecord(record);
-          this.markProcessExited(record, void 0, record.failureReason);
+          await this.markProcessExited(record, void 0, record.failureReason);
           return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
         }
         const closedAt = Date.now();
@@ -3975,25 +4232,33 @@ var init_studio_instance_manager = __esm({
         record.exitedAt = record.exitedAt ?? closedAt;
         if (record.state !== "failed")
           record.state = "exited";
+        record.processObservationStatus = "not_running";
+        record.lastProcessObservationAt = closedAt;
+        record.lastSuccessfulProcessObservationAt = closedAt;
+        record.lastProcessObservationError = void 0;
         this.cleanupManagedRecord(record);
         this.markClosedInMemory(record);
-        this.persist(record);
+        await this.persist(record);
         return { status: "closed", launchId: record.recordId, instanceId: record.instanceId };
       }
-      closeConnectedInstance(instance) {
-        const process2 = this.findProcessForConnectedInstance(instance);
+      async closeConnectedInstance(instance) {
+        const snapshot = await this.getProcessSnapshot(true);
+        if (snapshot.status === "error") {
+          throw new Error(`Could not enumerate Studio processes: ${snapshot.error}`);
+        }
+        const process2 = this.findProcessForConnectedInstance(instance, snapshot.processes);
         if (!process2) {
           throw new Error(`Could not find a Studio process for connected instance "${instance.instanceId}".`);
         }
-        this.closeProcess(process2.Id);
+        await this.closeProcess(process2.Id);
       }
-      closeProcess(processId) {
+      async closeProcess(processId) {
         if (this.processAdapter.stopProcess) {
-          this.processAdapter.stopProcess(processId);
+          await this.processAdapter.stopProcess(processId);
           return;
         }
         if (process.platform === "win32" || isWsl()) {
-          powershell(`Stop-Process -Id ${Math.trunc(processId)} -Force -ErrorAction Stop`);
+          await powershellAsync(`Stop-Process -Id ${Math.trunc(processId)} -Force -ErrorAction Stop`);
         } else {
           try {
             process.kill(processId, "SIGTERM");
@@ -4003,8 +4268,7 @@ var init_studio_instance_manager = __esm({
           }
         }
       }
-      findProcessForConnectedInstance(instance) {
-        const processes = this.listStudioProcesses();
+      findProcessForConnectedInstance(instance, processes) {
         if (processes.length === 0)
           return void 0;
         if (processes.length === 1)
@@ -4023,31 +4287,67 @@ var init_studio_instance_manager = __esm({
         }
         return void 0;
       }
-      listStudioProcesses() {
-        return this.processAdapter.listStudioProcesses?.() ?? listStudioProcesses();
+      async getProcessSnapshot(force = false) {
+        const now = Date.now();
+        if (!force && this.snapshotCacheMs > 0 && this.cachedSnapshot && now - this.cachedSnapshot.observedAt <= this.snapshotCacheMs) {
+          return this.cachedSnapshot;
+        }
+        if (this.snapshotInFlight)
+          return this.snapshotInFlight;
+        this.snapshotInFlight = (async () => {
+          try {
+            let snapshot;
+            if (this.processAdapter.observeStudioProcesses) {
+              snapshot = await this.processAdapter.observeStudioProcesses();
+            } else if (this.processAdapter.listStudioProcesses) {
+              const observedAt = Date.now();
+              const processes = await this.processAdapter.listStudioProcesses();
+              snapshot = { status: "ok", observedAt, processes };
+            } else {
+              snapshot = await observeStudioProcesses();
+            }
+            this.cachedSnapshot = snapshot;
+            return snapshot;
+          } catch (error) {
+            const snapshot = {
+              status: "error",
+              observedAt: Date.now(),
+              error: error instanceof Error ? error.message : String(error)
+            };
+            this.cachedSnapshot = snapshot;
+            return snapshot;
+          } finally {
+            this.snapshotInFlight = void 0;
+          }
+        })();
+        return this.snapshotInFlight;
       }
-      getCurrentBootId() {
-        return this.processAdapter.currentBootId?.() ?? currentBootId();
+      async getCurrentBootId() {
+        return this.processAdapter.currentBootId ? await this.processAdapter.currentBootId() : currentBootIdAsync();
       }
-      registrySweepOptions() {
+      async registrySweepOptions(snapshot) {
         return {
-          currentBootId: this.getCurrentBootId(),
-          isProcessRunning: (record) => this.isRegistryProcessRunning(record),
-          cleanupRecord: (record) => this.cleanupManagedRecord(record)
+          currentBootId: await this.getCurrentBootId(),
+          observeProcess: (record) => this.observeRecord(this.fromRegistryRecord(record), snapshot),
+          cleanupRecord: (record) => this.cleanupManagedRecord(record),
+          confirmedExitMisses: this.confirmedExitMisses,
+          confirmedExitGraceMs: this.confirmedExitGraceMs
         };
       }
-      sweepRegistry() {
-        this.registry.sweep(this.registrySweepOptions());
-      }
-      findProcessById(processId) {
-        return this.listStudioProcesses().find((proc) => proc.Id === processId);
+      async sweepRegistry(snapshot) {
+        await this.registry.sweep(await this.registrySweepOptions(snapshot));
       }
-      isRegistryProcessRunning(record) {
+      observeRecord(record, snapshot) {
+        if (snapshot.status === "error") {
+          return { status: "unknown", observedAt: snapshot.observedAt, error: snapshot.error };
+        }
         const processId = record.nativeProcessId ?? record.spawnPid;
         if (!processId)
-          return true;
-        const studioProcess = this.findProcessById(processId);
-        return !!studioProcess && this.verifyProcessForRecord(this.fromRegistryRecord(record), studioProcess);
+          return { status: "running", observedAt: snapshot.observedAt };
+        const studioProcess = snapshot.processes.find((candidate) => candidate.Id === processId);
+        if (!studioProcess)
+          return { status: "not_running", observedAt: snapshot.observedAt, reason: "missing" };
+        return this.verifyProcessForRecord(record, studioProcess) ? { status: "running", observedAt: snapshot.observedAt } : { status: "not_running", observedAt: snapshot.observedAt, reason: "identity_mismatch" };
       }
       verifyProcessForRecord(record, studioProcess) {
         const processName = `${studioProcess.Name ?? ""} ${studioProcess.Path ?? ""}`.toLowerCase();
@@ -4081,9 +4381,9 @@ var init_studio_instance_manager = __esm({
         if (record.instanceId)
           this.managedByInstanceId.delete(record.instanceId);
         this.pending.delete(record);
-        this.stopMonitor(record);
+        this.clearConnectionTimer(record);
       }
-      markProcessExited(record, exitCode, reason) {
+      async markProcessExited(record, exitCode, reason) {
         if (record.closedAt !== void 0)
           return record;
         const exitedAt = Date.now();
@@ -4091,43 +4391,44 @@ var init_studio_instance_manager = __esm({
         record.closedAt = exitedAt;
         if (record.state !== "failed")
           record.state = "exited";
+        record.processObservationStatus = "not_running";
+        record.lastProcessObservationAt = exitedAt;
+        record.lastSuccessfulProcessObservationAt = exitedAt;
+        record.lastProcessObservationError = void 0;
         if (exitCode !== void 0)
           record.exitCode = exitCode;
         if (reason)
           record.failureReason = reason;
         this.cleanupManagedRecord(record);
         this.markClosedInMemory(record);
-        this.persist(record);
+        await this.persist(record);
         return record;
       }
-      startMonitor(record) {
-        if (!record.recordId || record.closedAt !== void 0 || this.monitors.has(record.recordId))
+      startCoordinator(record) {
+        if (!record.recordId || record.closedAt !== void 0)
           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.");
+            this.runInBackground("persisting a Studio plugin connection timeout", 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)
+        if (this.coordinatorTimer)
           return;
-        const timer = this.monitors.get(record.recordId);
-        if (timer)
-          clearInterval(timer);
-        this.monitors.delete(record.recordId);
-        this.clearConnectionTimer(record);
+        this.coordinatorTimer = setInterval(() => {
+          if (this.coordinatorRefresh)
+            return;
+          this.coordinatorRefresh = this.refreshOwnedRecords().catch((error) => {
+            this.reportBackgroundFailure("refreshing managed Studio records", error);
+          }).finally(() => {
+            this.coordinatorRefresh = void 0;
+          });
+        }, 5e3);
+        if (typeof this.coordinatorTimer === "object" && "unref" in this.coordinatorTimer) {
+          this.coordinatorTimer.unref();
+        }
       }
       clearConnectionTimer(record) {
         if (!record.recordId)
@@ -4137,8 +4438,80 @@ var init_studio_instance_manager = __esm({
           clearTimeout(timer);
         this.connectionTimers.delete(record.recordId);
       }
-      persist(record) {
-        this.registry.upsert(this.toRegistryRecord(record));
+      async refreshOwnedRecords() {
+        const snapshot = await this.getProcessSnapshot(true);
+        await this.sweepRegistry(snapshot);
+        for (const record of [...this.managedByInstanceId.values(), ...this.pending]) {
+          await this.refresh(record, snapshot);
+        }
+      }
+      runInBackground(context, operation) {
+        void operation.catch((error) => this.reportBackgroundFailure(context, error));
+      }
+      reportBackgroundFailure(context, error) {
+        console.warn(`[robloxstudio-mcp] failed while ${context}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      async applyProcessObservation(record, observation) {
+        if (record.closedAt !== void 0)
+          return;
+        const previousObservationAt = record.lastProcessObservationAt;
+        record.lastProcessObservationAt = observation.observedAt;
+        if (observation.status === "unknown") {
+          record.processObservationStatus = "unknown";
+          record.lastProcessObservationError = observation.error;
+          record.consecutiveConfirmedMisses = 0;
+          record.firstConfirmedMissAt = void 0;
+          await this.persist(record);
+          return;
+        }
+        record.lastSuccessfulProcessObservationAt = observation.observedAt;
+        record.lastProcessObservationError = void 0;
+        if (observation.status === "running") {
+          record.processObservationStatus = "running";
+          record.consecutiveConfirmedMisses = 0;
+          record.firstConfirmedMissAt = void 0;
+          await this.persist(record);
+          return;
+        }
+        record.processObservationStatus = "not_running";
+        if (previousObservationAt !== observation.observedAt) {
+          record.consecutiveConfirmedMisses = (record.consecutiveConfirmedMisses ?? 0) + 1;
+          record.firstConfirmedMissAt ??= observation.observedAt;
+        }
+        const confirmedAbsent = observation.reason === "identity_mismatch" || (record.consecutiveConfirmedMisses ?? 0) >= this.confirmedExitMisses && observation.observedAt - (record.firstConfirmedMissAt ?? observation.observedAt) >= this.confirmedExitGraceMs;
+        if (!confirmedAbsent) {
+          await this.persist(record);
+          return;
+        }
+        await this.markProcessExited(record, void 0, observation.reason === "identity_mismatch" ? "Studio process identity changed; the retained PID was not reused." : record.instanceId ? "Studio process exited." : "Studio process exited before the MCP plugin connected.");
+      }
+      async reconcileFromPositiveEvidence(record, snapshot) {
+        if (record.closedAt === void 0)
+          return;
+        if (record.failureReason !== "Studio process exited." && record.failureReason !== "Studio process exited before the MCP plugin connected.")
+          return;
+        if (snapshot.status !== "ok")
+          return;
+        const processId = record.nativeProcessId ?? record.spawnPid;
+        const studioProcess = processId ? snapshot.processes.find((candidate) => candidate.Id === processId) : void 0;
+        if (!studioProcess || !this.verifyProcessForRecord(record, studioProcess))
+          return;
+        if (record.exitCode !== void 0)
+          return;
+        record.closedAt = void 0;
+        record.exitedAt = void 0;
+        record.failureReason = void 0;
+        record.state = record.instanceId ? "connected" : "launching";
+        record.processObservationStatus = "running";
+        record.lastProcessObservationAt = snapshot.observedAt;
+        record.lastSuccessfulProcessObservationAt = snapshot.observedAt;
+        record.lastProcessObservationError = void 0;
+        record.consecutiveConfirmedMisses = 0;
+        record.firstConfirmedMissAt = void 0;
+        await this.persist(record);
+      }
+      async persist(record) {
+        await this.registry.upsert(this.toRegistryRecord(record));
       }
       toRegistryRecord(record) {
         if (!record.recordId)
@@ -4170,7 +4543,13 @@ var init_studio_instance_manager = __esm({
           failureReason: record.failureReason,
           closedAt: record.closedAt,
           ownerPid: record.ownerPid,
-          bootId: record.bootId
+          bootId: record.bootId,
+          processObservationStatus: record.processObservationStatus,
+          lastProcessObservationAt: record.lastProcessObservationAt,
+          lastSuccessfulProcessObservationAt: record.lastSuccessfulProcessObservationAt,
+          lastProcessObservationError: record.lastProcessObservationError,
+          consecutiveConfirmedMisses: record.consecutiveConfirmedMisses,
+          firstConfirmedMissAt: record.firstConfirmedMissAt
         };
       }
       fromRegistryRecord(record) {
@@ -4199,7 +4578,13 @@ var init_studio_instance_manager = __esm({
           closedAt: record.closedAt,
           ownerPid: record.ownerPid,
           bootId: record.bootId,
-          deleteLocalPlaceFileOnClose: record.deleteLocalPlaceFileOnClose
+          deleteLocalPlaceFileOnClose: record.deleteLocalPlaceFileOnClose,
+          processObservationStatus: record.processObservationStatus,
+          lastProcessObservationAt: record.lastProcessObservationAt,
+          lastSuccessfulProcessObservationAt: record.lastSuccessfulProcessObservationAt,
+          lastProcessObservationError: record.lastProcessObservationError,
+          consecutiveConfirmedMisses: record.consecutiveConfirmedMisses,
+          firstConfirmedMissAt: record.firstConfirmedMissAt
         };
       }
     };
@@ -5010,7 +5395,7 @@ var init_esm = __esm({
 
 // ../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 { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import * as path4 from "path";
 function decompressLz4Block(input, outputLength) {
   const output = Buffer.allocUnsafe(outputLength);
@@ -5222,7 +5607,7 @@ function discoverNamedFile(root, fileName, depth = 0) {
   const matches = [];
   let entries;
   try {
-    entries = readdirSync3(root, { withFileTypes: true });
+    entries = readdirSync2(root, { withFileTypes: true });
   } catch {
     return matches;
   }
@@ -5236,7 +5621,7 @@ function discoverNamedFile(root, fileName, depth = 0) {
   }
   return matches;
 }
-function resolveAssistantBundlePath(studioExe = resolveStudioExe()) {
+function resolveAssistantBundlePath(studioExe) {
   const override = process.env.ROBLOX_STUDIO_ASSISTANT_BUNDLE;
   if (override) {
     if (!existsSync4(override)) {
@@ -5244,7 +5629,7 @@ function resolveAssistantBundlePath(studioExe = resolveStudioExe()) {
     }
     return override;
   }
-  const exeDirectory = path4.dirname(studioExe);
+  const exeDirectory = path4.dirname(studioExe ?? resolveStudioExe());
   const roots = [
     path4.join(exeDirectory, "BuiltInStandalonePlugins"),
     path4.resolve(exeDirectory, "..", "Resources", "BuiltInStandalonePlugins"),
@@ -5258,18 +5643,18 @@ function resolveAssistantBundlePath(studioExe = resolveStudioExe()) {
     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;
+  const newest = [...candidates].map((candidate) => ({ candidate, modifiedAt: statSync2(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);
+  const stats = statSync2(bundlePath);
   if (cachedBundle?.path === bundlePath && cachedBundle.modifiedAt === stats.mtimeMs && cachedBundle.size === stats.size) {
     return cachedBundle.value;
   }
-  const buffer = readFileSync5(bundlePath);
+  const buffer = readFileSync4(bundlePath);
   const skills = parseBuiltInStudioSkills(buffer);
   if (skills.length === 0) {
     throw new Error(`No built-in skill documents found in ${bundlePath}`);
@@ -6986,13 +7371,20 @@ var init_tools = __esm({
       openCloudClient;
       cookieClient;
       instanceManager;
+      managedConnectionAssociations = Promise.resolve();
       constructor(bridge) {
         this.client = new StudioHttpClient(bridge);
         this.bridge = bridge;
         this.openCloudClient = new OpenCloudClient();
         this.cookieClient = new RobloxCookieClient();
         this.instanceManager = new StudioInstanceManager();
-        this.bridge.onInstanceRegistered((instance) => this._associateManagedEditConnection(instance));
+        this.bridge.onInstanceRegistered((instance) => {
+          const instanceManager = this.instanceManager;
+          const association = this.managedConnectionAssociations.then(() => this._associateManagedEditConnection(instance, instanceManager));
+          this.managedConnectionAssociations = association.catch((error) => {
+            console.warn(`[robloxstudio-mcp] managed Studio connection association failed: ${error instanceof Error ? error.message : String(error)}`);
+          });
+        });
       }
       _textResult(body) {
         return { content: [{ type: "text", text: JSON.stringify(body) }] };
@@ -8573,9 +8965,9 @@ ${code}`
       _publicInstanceKey(instance) {
         return `${instance.instanceId}:${instance.role}:${instance.connectedAt}`;
       }
-      _isLatestPublishedPlaceOpen(placeId) {
+      async _isLatestPublishedPlaceOpen(placeId) {
         const publishedInstanceId2 = `place:${placeId}`;
-        return this.bridge.getPublicInstances().some((instance) => instance.placeId === placeId || instance.instanceId === publishedInstanceId2) || this.instanceManager.list().some((record) => record.closedAt === void 0 && record.source === "published_place" && record.placeId === placeId);
+        return this.bridge.getPublicInstances().some((instance) => instance.placeId === placeId || instance.instanceId === publishedInstanceId2) || (await this.instanceManager.list()).some((record) => record.closedAt === void 0 && record.source === "published_place" && record.placeId === placeId);
       }
       _matchesManagedLaunch(record, instance) {
         if (record.source === "published_place") {
@@ -8587,12 +8979,12 @@ ${code}`
         }
         return true;
       }
-      _associateManagedEditConnection(instance) {
+      async _associateManagedEditConnection(instance, instanceManager) {
         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];
+        const candidate = (await 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);
+          await instanceManager.attachInstanceId(candidate, instance.instanceId);
       }
       async _deriveUniverseId(placeId) {
         const response = await fetch(`https://apis.roblox.com/universes/v1/places/${placeId}/universe`);
@@ -8609,7 +9001,7 @@ ${code}`
       async _waitForManagedEditConnection(record, beforeKeys, timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
-          this.instanceManager.refresh(record);
+          await this.instanceManager.refresh(record);
           if (record.state === "failed" || record.state === "exited" || record.closedAt !== void 0) {
             return void 0;
           }
@@ -8621,7 +9013,6 @@ ${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,
@@ -8629,7 +9020,12 @@ ${code}`
           managed: true,
           state: record.state,
           pid: record.nativeProcessId ?? record.spawnPid,
-          process_running: record.closedAt === void 0 && record.exitedAt === void 0,
+          process_running: record.closedAt !== void 0 || record.exitedAt !== void 0 ? false : record.processObservationStatus === "running" ? true : record.processObservationStatus === "not_running" ? false : null,
+          process_observation_status: record.processObservationStatus ?? "unknown",
+          last_process_observation_at: record.lastProcessObservationAt ? new Date(record.lastProcessObservationAt).toISOString() : void 0,
+          last_successful_process_observation_at: record.lastSuccessfulProcessObservationAt ? new Date(record.lastSuccessfulProcessObservationAt).toISOString() : void 0,
+          last_process_observation_error: record.lastProcessObservationError,
+          consecutive_confirmed_misses: record.consecutiveConfirmedMisses ?? 0,
           source: record.source,
           local_place_file: record.localPlaceFile,
           place_id: record.placeId,
@@ -8681,15 +9077,18 @@ ${code}`
             body.next_page_token = response.nextPageToken;
           return this._textResult(body);
         }
+        if (action === "status" || action === "close") {
+          await this.managedConnectionAssociations;
+        }
         if (action === "status") {
           if (launch_id) {
-            const record2 = this.instanceManager.getByLaunchId(launch_id);
+            const record2 = await 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 record2 = await 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 });
@@ -8706,7 +9105,7 @@ ${code}`
             });
           }
           return this._textResult({
-            managed: this.instanceManager.list().filter((record2) => record2.closedAt === void 0).map((record2) => this._managedStatus(record2)),
+            managed: (await this.instanceManager.list()).filter((record2) => record2.closedAt === void 0).map((record2) => this._managedStatus(record2)),
             connected: this.bridge.getPublicInstances().map((instance) => ({
               instance_id: instance.instanceId,
               role: instance.role,
@@ -8718,11 +9117,11 @@ ${code}`
         if (action === "close") {
           let record2;
           if (launch_id) {
-            record2 = this.instanceManager.getByLaunchId(launch_id);
+            record2 = await 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" };
+            const closeResult2 = record2.closedAt === void 0 ? await this.instanceManager.close(record2) : { status: "already_closed" };
             if (connectedInstanceId) {
               await this.bridge.unregisterInstanceIdEverywhere(connectedInstanceId);
               await sleep(500);
@@ -8730,19 +9129,21 @@ ${code}`
             }
             return this._textResult({
               ...this._managedStatus(record2),
+              close_status: closeResult2.status,
               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);
+            const recordBeforeClose = await this.instanceManager.get(instance_id);
+            const managedClose = await 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);
+              const closedRecord = managedClose.launchId ? await this.instanceManager.getByLaunchId(managedClose.launchId) : recordBeforeClose;
               return this._textResult({
                 ...closedRecord ? this._managedStatus(closedRecord) : { instance_id },
+                close_status: managedClose.status,
                 message: managedClose.status === "already_closed" ? "Studio instance was already closed." : "Studio instance closed."
               });
             }
@@ -8755,7 +9156,7 @@ ${code}`
               });
             }
             try {
-              this.instanceManager.closeConnectedInstance(edit);
+              await this.instanceManager.closeConnectedInstance(edit);
               await sleep(500);
             } catch (error) {
               return this._textResult({
@@ -8766,10 +9167,11 @@ ${code}`
             await this.bridge.unregisterInstanceIdEverywhere(instance_id);
             return this._textResult({
               instance_id,
+              close_status: "closed",
               message: "Studio instance closed."
             });
           } else {
-            const active = this.instanceManager.list().filter((entry) => entry.closedAt === void 0);
+            const active = (await this.instanceManager.list()).filter((entry) => entry.closedAt === void 0);
             if (active.length === 0) {
               return this._textResult({ message: "No managed Studio instances are active." });
             }
@@ -8783,13 +9185,14 @@ ${code}`
           }
           if (record2.instanceId)
             await this.bridge.unregisterInstanceIdEverywhere(record2.instanceId);
-          const closeResult = this.instanceManager.close(record2);
+          const closeResult = await this.instanceManager.close(record2);
           if (record2.instanceId) {
             await sleep(500);
             await this.bridge.unregisterInstanceIdEverywhere(record2.instanceId);
           }
           return this._textResult({
             ...this._managedStatus(record2),
+            close_status: closeResult.status,
             message: closeResult.status === "already_closed" ? "Studio instance was already closed." : "Studio instance closed."
           });
         }
@@ -8801,7 +9204,15 @@ ${code}`
         const placeId = launchSource === "published_place" || launchSource === "place_revision" ? this._positiveInteger(request.place_id, "place_id") : void 0;
         const placeVersion = launchSource === "place_revision" ? this._positiveInteger(request.place_version, "place_version") : void 0;
         const localPlaceFile = typeof request.local_place_file === "string" ? request.local_place_file : void 0;
-        if (launchSource === "published_place" && placeId !== void 0 && this._isLatestPublishedPlaceOpen(placeId)) {
+        let studioExecutable;
+        if (request.studio_executable !== void 0) {
+          if (typeof request.studio_executable !== "string" || request.studio_executable.length === 0) {
+            throw new Error("studio_executable must be a non-empty string when provided.");
+          }
+          studioExecutable = request.studio_executable;
+        }
+        const processEnvironment = parseStudioProcessEnvironmentPatch(request.process_environment);
+        if (launchSource === "published_place" && placeId !== void 0 && await this._isLatestPublishedPlaceOpen(placeId)) {
           return this._textResult({
             error: "Place is already open.",
             message: `place_id ${placeId} is already connected. Use the existing instance or launch a specific place_revision.`
@@ -8817,7 +9228,9 @@ ${code}`
           placeId,
           universeId,
           placeVersion,
-          connectionTimeoutMs: timeoutMs
+          connectionTimeoutMs: timeoutMs,
+          studioExecutable,
+          processEnvironment
         });
         if (!waitForConnection) {
           return this._textResult({
@@ -8828,11 +9241,11 @@ ${code}`
         const connected = await this._waitForManagedEditConnection(record, beforeKeys, timeoutMs);
         if (!connected) {
           if (record.state === "launching") {
-            this.instanceManager.markFailed(record, "Studio launched, but the MCP plugin did not connect before timeout.");
+            await 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);
+              await this.instanceManager.close(record);
             } catch {
             }
           }
@@ -8841,7 +9254,7 @@ ${code}`
             error: record.failureReason ?? "Studio launched, but the MCP plugin did not connect before timeout."
           });
         }
-        this.instanceManager.attachInstanceId(record, connected.instanceId);
+        await this.instanceManager.attachInstanceId(record, connected.instanceId);
         return this._textResult({
           ...this._managedStatus(record),
           message: launchSource === "place_revision" ? `Studio opened place revision ${placeVersion}.` : "Studio opened."
@@ -11874,6 +12287,35 @@ var init_definitions = __esm({
               type: "number",
               description: 'For action="launch": max milliseconds for plugin connection (default 120000). The deadline also applies asynchronously when wait_for_connection=false.'
             },
+            studio_executable: {
+              type: "string",
+              description: 'For action="launch": exact Roblox Studio executable to launch instead of auto-discovering a version.'
+            },
+            process_environment: {
+              type: "object",
+              description: 'For action="launch": process-scoped environment patch applied only while creating Studio. Values are never retained in the managed-instance registry.',
+              properties: {
+                set: {
+                  type: "object",
+                  description: "Environment variables to set for the Studio process.",
+                  propertyNames: {
+                    pattern: "^[A-Za-z_][A-Za-z0-9_]*$"
+                  },
+                  additionalProperties: {
+                    type: "string"
+                  }
+                },
+                remove: {
+                  type: "array",
+                  description: "Environment variables to remove from the Studio process environment.",
+                  items: {
+                    type: "string",
+                    pattern: "^[A-Za-z_][A-Za-z0-9_]*$"
+                  }
+                }
+              },
+              additionalProperties: false
+            },
             max_page_size: {
               type: "number",
               description: 'For action="list_place_versions": number of versions to return, clamped to 1-50 (default 10).'
@@ -12243,7 +12685,7 @@ var init_definitions = __esm({
       {
         name: "get_runtime_logs",
         category: "read",
-        description: "Read the in-memory log buffers captured by Studio plugin peers. Each buffer captures ~64 KB of recent LogService output; runtime peers seed from LogService:GetLogHistory() at plugin load so early startup logs emitted before the plugin finishes loading can still be returned, then continue capturing LogService.MessageOut entries. Oldest entries drop when over budget. Entries include capturedBy for the plugin buffer that observed the log. In ordinary Studio play/run sessions, LogService reflects logs across edit/server/client, so script-origin peer is not reliable and entries omit peer. In StudioTestService multiplayer sessions only, peer attribution is reliable and entries also include peer. target=all (default) merges buffers and dedups same-message-and-level entries captured within 2s across different buffers.",
+        description: "Read the in-memory log buffers captured by Studio plugin peers. Each buffer captures ~64 KB of recent LogService output; runtime peers seed from LogService:GetLogHistory() at plugin load so early startup logs emitted before the plugin finishes loading can still be returned, then continue capturing LogService.MessageOut entries. Live structured LogService entries include their context dictionary as optional data; Roblox GetLogHistory does not expose context for entries seeded at plugin load. Oldest entries drop when over budget. Entries include capturedBy for the plugin buffer that observed the log. In ordinary Studio play/run sessions, LogService reflects logs across edit/server/client, so script-origin peer is not reliable and entries omit peer. In StudioTestService multiplayer sessions only, peer attribution is reliable and entries also include peer. target=all (default) merges buffers and dedups same-message-and-level entries captured within 2s across different buffers.",
         inputSchema: {
           type: "object",
           properties: {
@@ -13670,7 +14112,7 @@ part(0,2,0,2,1,1,"b")`,
 });
 
 // ../core/dist/install-plugin-helpers.js
-import { existsSync as existsSync6, readFileSync as readFileSync7, unlinkSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6, unlinkSync } from "fs";
 import { execSync } from "child_process";
 import { join as join6 } from "path";
 import { homedir as homedir5 } from "os";
@@ -13678,7 +14120,7 @@ function isWSL() {
   if (process.platform !== "linux")
     return false;
   try {
-    const v = readFileSync7("/proc/version", "utf8");
+    const v = readFileSync6("/proc/version", "utf8");
     return /microsoft|wsl/i.test(v);
   } catch {
     return false;
@@ -13763,7 +14205,7 @@ __export(install_plugin_exports, {
   installBundledPlugin: () => installBundledPlugin,
   installPlugin: () => installPlugin
 });
-import { copyFileSync as copyFileSync2, createWriteStream, existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync8, unlinkSync as unlinkSync2 } from "fs";
+import { copyFileSync as copyFileSync2, createWriteStream, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, unlinkSync as unlinkSync2 } from "fs";
 import { dirname as dirname5, join as join7 } from "path";
 import { fileURLToPath } from "url";
 import { get } from "https";
@@ -13825,7 +14267,7 @@ function prepareInstall({
 }) {
   const pluginsFolder = getPluginsFolder();
   if (!existsSync7(pluginsFolder)) {
-    mkdirSync5(pluginsFolder, { recursive: true });
+    mkdirSync4(pluginsFolder, { recursive: true });
   }
   handleVariantConflict({
     pluginsFolder,
@@ -13846,14 +14288,14 @@ function bundledAssetPath() {
 }
 function packageVersion() {
   const currentDir = dirname5(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync8(join7(currentDir, "..", "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync7(join7(currentDir, "..", "package.json"), "utf8"));
   if (!pkg.version) {
     throw new Error("Package version not found");
   }
   return pkg.version;
 }
 function bundledPluginVersion(source) {
-  const match = readFileSync8(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
+  const match = readFileSync7(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
   return match ? match[1] : null;
 }
 function assertBundledPluginVersion(source) {
@@ -13867,8 +14309,8 @@ function assertBundledPluginVersion(source) {
 }
 function filesMatch(a, b) {
   if (!existsSync7(b)) return false;
-  const aBytes = readFileSync8(a);
-  const bBytes = readFileSync8(b);
+  const aBytes = readFileSync7(a);
+  const bBytes = readFileSync7(b);
   return aBytes.length === bBytes.length && aBytes.equals(bBytes);
 }
 async function installBundledPlugin(options = {}) {