@chrrxs/robloxstudio-mcp-inspector 2.22.3 → 2.22.4

package/dist/index.js

@@ -3073,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() {
@@ -3088,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);
@@ -3104,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 {
@@ -3198,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);
@@ -3240,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,
@@ -3290,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"
@@ -3307,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"
@@ -3319,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"
@@ -3330,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,
@@ -3343,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,
@@ -3359,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);
         }
       }
     };
@@ -3382,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",
@@ -3394,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()
   });
 }
@@ -3421,15 +3526,33 @@ 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, "''")}'`;
@@ -3513,9 +3636,8 @@ function quoteWindowsCommandLineArg(value) {
   }
   return `${quoted}${"\\".repeat(backslashes * 2)}"`;
 }
-function buildWindowsStudioStartScript(exe, args, processEnvironment) {
+function buildWindowsStudioStartScriptFromConvertedExe(windowsExe, args, processEnvironment) {
   const environmentPatch = parseStudioProcessEnvironmentPatch(processEnvironment);
-  const windowsExe = toStudioLaunchArg(exe);
   const commandLine = args.map(quoteWindowsCommandLineArg).join(" ");
   return [
     ...environmentPatch ? powershellEnvironmentPatchStatements(environmentPatch) : [],
@@ -3524,7 +3646,7 @@ function buildWindowsStudioStartScript(exe, args, processEnvironment) {
     `$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",
@@ -3532,9 +3654,10 @@ function buildWindowsStudioStartScript(exe, args, processEnvironment) {
     'if ($null -eq $studio) { throw "Roblox Studio process did not start." }'
   ].join("; ");
 }
-function spawnWindowsStudioFromWsl(exe, args, processEnvironment) {
-  const script = buildWindowsStudioStartScript(exe, args, processEnvironment);
-  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;
@@ -3576,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;
@@ -3587,7 +3710,7 @@ function isProcessAlive(pid) {
 function sweepStaleBaseplateFiles() {
   let entries;
   try {
-    entries = readdirSync2(BASEPLATE_TEMP_DIR);
+    entries = readdirSync(BASEPLATE_TEMP_DIR);
   } catch {
     return;
   }
@@ -3596,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);
@@ -3624,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 {
     }
   }
@@ -3651,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 {
     }
   }
@@ -3737,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, ENVIRONMENT_VARIABLE_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";
@@ -3751,27 +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;
@@ -3780,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;
@@ -3808,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)
@@ -3820,47 +3988,59 @@ 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 = preparedOptions.studioExecutable ?? 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,
@@ -3870,9 +4050,9 @@ var init_studio_instance_manager = __esm({
         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, processEnvironment);
+            proc = await spawnWindowsStudioFromWsl(exe, args, processEnvironment);
           } else {
             const child = spawn(exe, args, spawnOptions);
             proc = {
@@ -3891,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,
@@ -3903,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;
             }
@@ -3931,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) {
@@ -3970,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,
@@ -3994,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 };
         }
@@ -4004,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,
@@ -4042,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();
@@ -4050,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");
@@ -4078,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)
@@ -4098,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());
+      async sweepRegistry(snapshot) {
+        await this.registry.sweep(await this.registrySweepOptions(snapshot));
       }
-      findProcessById(processId) {
-        return this.listStudioProcesses().find((proc) => proc.Id === processId);
-      }
-      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();
@@ -4156,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();
@@ -4166,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)
@@ -4212,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)
@@ -4245,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) {
@@ -4274,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
         };
       }
     };
@@ -5085,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);
@@ -5297,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;
   }
@@ -5311,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)) {
@@ -5319,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"),
@@ -5333,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}`);
@@ -7061,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) }] };
@@ -8648,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") {
@@ -8662,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`);
@@ -8684,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;
           }
@@ -8696,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,
@@ -8704,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,
@@ -8756,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 });
@@ -8781,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,
@@ -8793,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);
@@ -8810,13 +9134,13 @@ ${code}`
             });
           }
           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,
@@ -8832,7 +9156,7 @@ ${code}`
               });
             }
             try {
-              this.instanceManager.closeConnectedInstance(edit);
+              await this.instanceManager.closeConnectedInstance(edit);
               await sleep(500);
             } catch (error) {
               return this._textResult({
@@ -8847,7 +9171,7 @@ ${code}`
               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." });
             }
@@ -8861,7 +9185,7 @@ ${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);
@@ -8888,7 +9212,7 @@ ${code}`
           studioExecutable = request.studio_executable;
         }
         const processEnvironment = parseStudioProcessEnvironmentPatch(request.process_environment);
-        if (launchSource === "published_place" && placeId !== void 0 && this._isLatestPublishedPlaceOpen(placeId)) {
+        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.`
@@ -8917,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 {
             }
           }
@@ -8930,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."
@@ -13788,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";
@@ -13796,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;
@@ -13881,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";
@@ -13943,7 +14267,7 @@ function prepareInstall({
 }) {
   const pluginsFolder = getPluginsFolder();
   if (!existsSync7(pluginsFolder)) {
-    mkdirSync5(pluginsFolder, { recursive: true });
+    mkdirSync4(pluginsFolder, { recursive: true });
   }
   handleVariantConflict({
     pluginsFolder,
@@ -13964,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) {
@@ -13985,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 = {}) {