@chrrxs/robloxstudio-mcp-inspector 2.22.3 → 2.22.5

package/dist/index.js

@@ -974,7 +974,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       serverVersion: serverConfig?.version,
       capabilities: studioLifecycleCallable ? {
         studioLifecycle: {
-          protocolVersion: 1,
+          protocolVersion: 3,
           endpoint: "/mcp/manage_instance"
         }
       } : {},
@@ -3024,34 +3024,124 @@ var init_roblox_cookie_client = __esm({
         }
         return response;
       }
-      async uploadDecal(fileContent, name, description) {
+      async uploadImage(options) {
         if (!this.cookie) {
           throw new Error("ROBLOSECURITY cookie is not set.");
         }
-        const encodedName = encodeURIComponent(name);
-        const encodedDesc = encodeURIComponent(description);
-        const url = `https://data.roblox.com/data/upload/json?assetTypeId=13&name=${encodedName}&description=${encodedDesc}`;
-        const response = await this.fetchWithCsrf(url, {
+        const creator = await this.resolveCreator(options.userId, options.groupId);
+        const request = {
+          assetType: "Image",
+          displayName: options.displayName,
+          description: options.description,
+          creationContext: { creator }
+        };
+        const formData = new FormData();
+        formData.append("request", JSON.stringify(request));
+        formData.append("fileContent", new Blob([new Uint8Array(options.fileContent)], { type: this.getImageMimeType(options.fileName) }), options.fileName);
+        const response = await this.fetchWithCsrf("https://apis.roblox.com/assets/user-auth/v1/assets", {
           method: "POST",
-          headers: {
-            "Content-Type": "application/octet-stream",
-            "User-Agent": "RobloxStudio/WinInet",
-            Requester: "Client"
-          },
-          body: new Uint8Array(fileContent)
+          body: formData
         });
+        const operation = await this.readOperation(response, "Image upload");
+        return { assetId: await this.completeOperation(operation) };
+      }
+      async resolveCreator(userId, groupId) {
+        if (groupId)
+          return { groupId };
+        if (userId)
+          return { userId };
+        const response = await this.fetchWithCsrf("https://users.roblox.com/v1/users/authenticated");
         if (!response.ok) {
           const body = await response.text();
-          throw new Error(`Decal upload failed (${response.status}): ${body}`);
+          throw new Error(`Failed to resolve authenticated Roblox user (${response.status}): ${body}`);
         }
-        const result = await response.json();
-        if (!result.Success || !result.AssetId) {
-          throw new Error(`Decal upload failed: ${result.Message || "Unknown error"}`);
+        const authenticatedUser = await response.json();
+        const resolvedUserId = String(authenticatedUser.id ?? "");
+        if (!/^\d+$/.test(resolvedUserId) || resolvedUserId === "0") {
+          throw new Error("Authenticated Roblox user response did not include a valid user ID.");
         }
-        return {
-          assetId: result.AssetId,
-          backingAssetId: result.BackingAssetId || 0
+        return { userId: resolvedUserId };
+      }
+      getImageMimeType(fileName) {
+        const extension = fileName.split(".").pop()?.toLowerCase();
+        const mimeTypes = {
+          png: "image/png",
+          jpg: "image/jpeg",
+          jpeg: "image/jpeg",
+          bmp: "image/bmp",
+          tga: "image/tga"
         };
+        const mimeType = extension ? mimeTypes[extension] : void 0;
+        if (mimeType)
+          return mimeType;
+        throw new Error(`Unsupported image format: .${extension ?? "(none)"}. Supported: png/jpg/jpeg/bmp/tga`);
+      }
+      async readOperation(response, action) {
+        const body = await response.text();
+        if (!response.ok) {
+          throw new Error(`${action} failed (${response.status}): ${body}`);
+        }
+        try {
+          return JSON.parse(body);
+        } catch {
+          throw new Error(`${action} returned malformed JSON: ${body}`);
+        }
+      }
+      operationAssetId(operation) {
+        const rawAssetId = operation.response?.assetId;
+        if (rawAssetId === void 0)
+          return null;
+        const assetId = Number(rawAssetId);
+        if (!Number.isSafeInteger(assetId) || assetId <= 0) {
+          throw new Error(`Image upload returned an invalid asset ID: ${String(rawAssetId)}`);
+        }
+        return assetId;
+      }
+      operationError(operation) {
+        if (operation.error?.message)
+          return operation.error.message;
+        if (operation.response?.message && operation.response.assetId === void 0) {
+          return operation.response.message;
+        }
+        if (operation.message)
+          return operation.message;
+        return null;
+      }
+      async completeOperation(operation) {
+        const initialError = this.operationError(operation);
+        if (initialError)
+          throw new Error(`Image upload failed: ${initialError}`);
+        const initialAssetId = this.operationAssetId(operation);
+        if (initialAssetId !== null)
+          return initialAssetId;
+        if (operation.done) {
+          throw new Error("Image upload completed without an asset ID.");
+        }
+        const operationId = operation.operationId ?? operation.path?.split("/").pop();
+        if (!operationId) {
+          throw new Error("Image upload response did not include an operation ID.");
+        }
+        return this.pollOperation(operationId);
+      }
+      async pollOperation(operationId, maxAttempts = 30, intervalMs = 2e3) {
+        const url = `https://apis.roblox.com/assets/user-auth/v1/operations/${encodeURIComponent(operationId)}`;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+          const response = await this.fetchWithCsrf(url);
+          const operation = await this.readOperation(response, "Image upload status");
+          const operationError = this.operationError(operation);
+          if (operationError)
+            throw new Error(`Image upload failed: ${operationError}`);
+          const assetId = this.operationAssetId(operation);
+          if (assetId !== null)
+            return assetId;
+          if (operation.done) {
+            throw new Error("Image upload completed without an asset ID.");
+          }
+          if (attempt < maxAttempts - 1) {
+            await new Promise((resolve5) => setTimeout(resolve5, intervalMs));
+          }
+        }
+        throw new Error(`Image upload timed out after ${maxAttempts * intervalMs / 1e3}s. Operation ID: ${operationId}`);
       }
       async getAssetDetails(assetIds) {
         if (!this.cookie) {
@@ -3073,7 +3163,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 +3179,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 +3195,134 @@ 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, activeLockPaths, 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();
+    activeLockPaths = /* @__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);
+            activeLockPaths.add(lockDir);
+            try {
+              await fs.writeFile(path.join(lockDir, "owner.json"), `${JSON.stringify(owner)}
+`, {
+                encoding: "utf8",
+                flag: "wx"
+              });
+            } catch (error) {
+              activeLockTokens.delete(owner.token);
+              activeLockPaths.delete(lockDir);
+              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 && !activeLockPaths.has(lockDir) && Date.now() - stat2.mtimeMs > LOCK_STALE_MS) {
+                await fs.rm(lockDir, { recursive: true, force: true });
                 continue;
               }
             } catch {
@@ -3198,40 +3331,59 @@ 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);
+            activeLockPaths.delete(lockDir);
+          }
+        }
+      }
+      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 +3392,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 +3442,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 +3459,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 +3471,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 +3482,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 +3495,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 +3511,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 +3568,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 +3581,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 +3620,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,41 +3730,556 @@ 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(" ");
+  const commandLine = [windowsExe, ...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
-    // PowerShell already printed the PID. Shell execution prevents that
-    // inheritance while Process.Start still returns the native Studio PID.
-    "$psi.UseShellExecute = $true",
-    "$studio = [System.Diagnostics.Process]::Start($psi)",
-    'if ($null -eq $studio) { throw "Roblox Studio process did not start." }'
+    `Add-Type -TypeDefinition @'
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public sealed class McpSuspendedStudio : IDisposable
+{
+    private const uint CREATE_SUSPENDED = 0x00000004;
+    private const uint CREATE_BREAKAWAY_FROM_JOB = 0x01000000;
+    private const uint RESUME_FAILED = 0xFFFFFFFF;
+    private const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000;
+    private const int JOB_OBJECT_EXTENDED_LIMIT_INFORMATION = 9;
+    private const uint WAIT_OBJECT_0 = 0x00000000;
+    private const uint WAIT_TIMEOUT = 0x00000102;
+    private const uint WAIT_FAILED = 0xFFFFFFFF;
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct StartupInfo
+    {
+        public int cb;
+        public string lpReserved;
+        public string lpDesktop;
+        public string lpTitle;
+        public uint dwX;
+        public uint dwY;
+        public uint dwXSize;
+        public uint dwYSize;
+        public uint dwXCountChars;
+        public uint dwYCountChars;
+        public uint dwFillAttribute;
+        public uint dwFlags;
+        public short wShowWindow;
+        public short cbReserved2;
+        public IntPtr lpReserved2;
+        public IntPtr hStdInput;
+        public IntPtr hStdOutput;
+        public IntPtr hStdError;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct ProcessInformation
+    {
+        public IntPtr hProcess;
+        public IntPtr hThread;
+        public uint dwProcessId;
+        public uint dwThreadId;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct FileTime
+    {
+        public uint Low;
+        public uint High;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct BasicLimitInformation
+    {
+        public long PerProcessUserTimeLimit;
+        public long PerJobUserTimeLimit;
+        public uint LimitFlags;
+        public UIntPtr MinimumWorkingSetSize;
+        public UIntPtr MaximumWorkingSetSize;
+        public uint ActiveProcessLimit;
+        public UIntPtr Affinity;
+        public uint PriorityClass;
+        public uint SchedulingClass;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct IoCounters
+    {
+        public ulong ReadOperationCount;
+        public ulong WriteOperationCount;
+        public ulong OtherOperationCount;
+        public ulong ReadTransferCount;
+        public ulong WriteTransferCount;
+        public ulong OtherTransferCount;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct ExtendedLimitInformation
+    {
+        public BasicLimitInformation BasicLimitInformation;
+        public IoCounters IoInfo;
+        public UIntPtr ProcessMemoryLimit;
+        public UIntPtr JobMemoryLimit;
+        public UIntPtr PeakProcessMemoryUsed;
+        public UIntPtr PeakJobMemoryUsed;
+    }
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern bool CreateProcessW(
+        string applicationName,
+        StringBuilder commandLine,
+        IntPtr processAttributes,
+        IntPtr threadAttributes,
+        bool inheritHandles,
+        uint creationFlags,
+        IntPtr environment,
+        string currentDirectory,
+        ref StartupInfo startupInfo,
+        out ProcessInformation processInformation);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern IntPtr CreateJobObjectW(IntPtr jobAttributes, string name);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool SetInformationJobObject(
+        IntPtr job,
+        int informationClass,
+        IntPtr information,
+        uint informationLength);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool GetProcessTimes(
+        IntPtr process,
+        out FileTime creation,
+        out FileTime exit,
+        out FileTime kernel,
+        out FileTime user);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern uint ResumeThread(IntPtr thread);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool TerminateProcess(IntPtr process, uint exitCode);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+
+    [DllImport("kernel32.dll")]
+    private static extern bool CloseHandle(IntPtr handle);
+
+    private IntPtr process;
+    private IntPtr thread;
+
+    private IntPtr job;
+    public uint ProcessId { get; private set; }
+    public ulong StartedAtFileTime { get; private set; }
+
+    private McpSuspendedStudio(ProcessInformation processInformation, IntPtr jobHandle)
+    {
+        process = processInformation.hProcess;
+        thread = processInformation.hThread;
+        job = jobHandle;
+        ProcessId = processInformation.dwProcessId;
+        FileTime creation;
+        FileTime exit;
+        FileTime kernel;
+        FileTime user;
+        if (!GetProcessTimes(process, out creation, out exit, out kernel, out user))
+            throw new Win32Exception(Marshal.GetLastWin32Error(), "GetProcessTimes failed");
+        StartedAtFileTime = ((ulong)creation.High << 32) | creation.Low;
+    }
+
+    private static void ConfigureKillOnClose(IntPtr jobHandle, bool enabled)
+    {
+        var information = new ExtendedLimitInformation();
+        information.BasicLimitInformation.LimitFlags = enabled ? JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE : 0;
+        int length = Marshal.SizeOf(typeof(ExtendedLimitInformation));
+        IntPtr buffer = Marshal.AllocHGlobal(length);
+        try
+        {
+            Marshal.StructureToPtr(information, buffer, false);
+            if (!SetInformationJobObject(jobHandle, JOB_OBJECT_EXTENDED_LIMIT_INFORMATION, buffer, (uint)length))
+                throw new Win32Exception(Marshal.GetLastWin32Error(), "SetInformationJobObject failed");
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(buffer);
+        }
+    }
+
+    private static void TerminateAndWait(IntPtr processHandle)
+    {
+        if (!TerminateProcess(processHandle, 1))
+        {
+            int error = Marshal.GetLastWin32Error();
+            if (error != 5)
+                throw new Win32Exception(error, "TerminateProcess failed");
+        }
+        uint wait = WaitForSingleObject(processHandle, 15000);
+        if (wait == WAIT_TIMEOUT)
+            throw new TimeoutException("Timed out waiting for the terminated Studio process");
+        if (wait == WAIT_FAILED)
+            throw new Win32Exception(Marshal.GetLastWin32Error(), "WaitForSingleObject failed");
+        if (wait != WAIT_OBJECT_0)
+            throw new InvalidOperationException("Unexpected Studio process wait result: " + wait);
+    }
+
+    public static McpSuspendedStudio Start(string application, string commandLine)
+    {
+        IntPtr jobHandle = CreateJobObjectW(IntPtr.Zero, null);
+        if (jobHandle == IntPtr.Zero)
+            throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateJobObjectW failed");
+        try
+        {
+            ConfigureKillOnClose(jobHandle, true);
+            var startup = new StartupInfo();
+            startup.cb = Marshal.SizeOf(startup);
+            ProcessInformation created;
+            uint flags = CREATE_SUSPENDED | CREATE_BREAKAWAY_FROM_JOB;
+            bool started = CreateProcessW(application, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, false, flags, IntPtr.Zero, null, ref startup, out created);
+            if (!started && Marshal.GetLastWin32Error() == 5)
+                started = CreateProcessW(application, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, false, CREATE_SUSPENDED, IntPtr.Zero, null, ref startup, out created);
+            if (!started)
+                throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateProcessW failed");
+            try
+            {
+                if (!AssignProcessToJobObject(jobHandle, created.hProcess))
+                    throw new Win32Exception(Marshal.GetLastWin32Error(), "AssignProcessToJobObject failed");
+                return new McpSuspendedStudio(created, jobHandle);
+            }
+            catch
+            {
+                try
+                {
+                    TerminateAndWait(created.hProcess);
+                }
+                finally
+                {
+                    CloseHandle(created.hThread);
+                    CloseHandle(created.hProcess);
+                }
+                throw;
+            }
+        }
+        catch
+        {
+            CloseHandle(jobHandle);
+            throw;
+        }
+    }
+
+    public void Resume()
+    {
+        if (thread == IntPtr.Zero)
+            throw new InvalidOperationException("Studio launch was already resumed or disposed");
+        if (ResumeThread(thread) == RESUME_FAILED)
+            throw new Win32Exception(Marshal.GetLastWin32Error(), "ResumeThread failed");
+        CloseHandle(thread);
+        thread = IntPtr.Zero;
+    }
+
+    public void Release()
+    {
+        if (thread != IntPtr.Zero)
+            throw new InvalidOperationException("Studio launch cannot be released before it is resumed");
+        if (job == IntPtr.Zero)
+            throw new InvalidOperationException("Studio launch was already released or disposed");
+        ConfigureKillOnClose(job, false);
+        CloseHandle(job);
+        job = IntPtr.Zero;
+    }
+
+    public void Abort()
+    {
+        if (process != IntPtr.Zero)
+            TerminateAndWait(process);
+    }
+
+    public void Dispose()
+    {
+        if (thread != IntPtr.Zero)
+        {
+            CloseHandle(thread);
+            thread = IntPtr.Zero;
+        }
+        if (job != IntPtr.Zero)
+        {
+            CloseHandle(job);
+            job = IntPtr.Zero;
+        }
+        if (process != IntPtr.Zero)
+        {
+            CloseHandle(process);
+            process = IntPtr.Zero;
+        }
+    }
+}
+'@`,
+    `$launch = [McpSuspendedStudio]::Start(${powershellStringLiteral(windowsExe)}, ${powershellStringLiteral(commandLine)})`,
+    "try {",
+    "[Console]::Out.WriteLine((ConvertTo-Json @{ pid = $launch.ProcessId; started = [string]$launch.StartedAtFileTime } -Compress)); [Console]::Out.Flush()",
+    "$accepted = $false",
+    "$command = [Console]::In.ReadLine()",
+    'if ($command -eq "MCP_STUDIO_LAUNCH_ACCEPT") {',
+    "$launch.Resume()",
+    '[Console]::Out.WriteLine("MCP_STUDIO_LAUNCH_RESUMED"); [Console]::Out.Flush()',
+    "$command = [Console]::In.ReadLine()",
+    'if ($command -eq "MCP_STUDIO_LAUNCH_COMPLETE") { $launch.Release(); $accepted = $true }',
+    'elseif ($command -eq "MCP_STUDIO_LAUNCH_ABORT") { $launch.Abort(); $accepted = $true }',
+    'else { throw "Resumed Studio launch was not completed or aborted." }',
+    '} elseif ($command -eq "MCP_STUDIO_LAUNCH_ABORT") { $launch.Abort(); $accepted = $true }',
+    'else { throw "Studio launch identity was not accepted." }',
+    "} finally {",
+    "try { if (-not $accepted) { $launch.Abort() } } finally { $launch.Dispose() }",
+    "}"
+  ].join("\n");
+}
+function buildWindowsStudioStopScript(processId, startedAt) {
+  if (!Number.isSafeInteger(processId) || processId <= 0)
+    throw new Error("processId must be a positive integer.");
+  if (!/^[1-9]\d*$/u.test(startedAt))
+    throw new Error("startedAt must be a positive FILETIME string.");
+  return [
+    `$processId = [int]${processId}`,
+    `$expectedStartedAt = [long]${startedAt}`,
+    "$studio = $null",
+    "try { $studio = [System.Diagnostics.Process]::GetProcessById($processId) } catch [System.ArgumentException] { return }",
+    "try {",
+    "$actualStartedAt = $studio.StartTime.ToUniversalTime().ToFileTimeUtc()",
+    "if ($actualStartedAt -ne $expectedStartedAt) { return }",
+    "if (-not $studio.HasExited) {",
+    "try { $studio.Kill() } catch { if (-not $studio.HasExited) { throw } }",
+    "$studio.WaitForExit()",
+    "}",
+    "} finally { if ($null -ne $studio) { $studio.Dispose() } }"
   ].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`);
-  const parsed = JSON.parse(output);
-  const nativePid = Number(parsed.pid);
-  const nativeStartedAt = typeof parsed.started === "string" && /^\d+$/u.test(parsed.started) ? parsed.started : void 0;
-  if (!Number.isSafeInteger(nativePid) || nativePid <= 0) {
-    throw new Error(`Could not determine the Windows Studio process id from: ${nativePid}`);
-  }
-  return {
-    pid: nativePid,
-    nativePid,
-    nativeStartedAt,
-    unref: () => {
-    }
-  };
+async function stopWindowsStudio(processId, startedAt) {
+  await powershellAsync(buildWindowsStudioStopScript(processId, startedAt));
+}
+async function spawnWindowsStudio(exe, args, processEnvironment) {
+  const windowsExe = await toStudioLaunchArgAsync(exe);
+  const script = buildWindowsStudioStartScriptFromConvertedExe(windowsExe, args, processEnvironment);
+  const launcher = spawn("powershell.exe", ["-NoProfile", "-Command", script], {
+    cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd(),
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true
+  });
+  return new Promise((resolve5, reject) => {
+    let stdout = "";
+    let controlOutput = "";
+    let stderr = "";
+    let identity;
+    let initialFailure;
+    let identitySettled = false;
+    let controlState = "pending";
+    let resumeSettled = false;
+    let completeResume;
+    const resumeAcknowledgment = new Promise((complete) => {
+      completeResume = complete;
+    });
+    const signalResume = (error) => {
+      if (resumeSettled)
+        return;
+      resumeSettled = true;
+      completeResume(error);
+    };
+    let completeLauncher;
+    const launcherCompletion = new Promise((complete) => {
+      completeLauncher = complete;
+    });
+    const waitForLauncherCompletion = (timeoutMessage) => new Promise((complete) => {
+      let settled = false;
+      const forceTimeout = setTimeout(() => {
+        if (settled)
+          return;
+        settled = true;
+        const error = new Error(timeoutMessage);
+        launcher.kill("SIGKILL");
+        signalResume(error);
+        completeLauncher(error);
+        complete(error);
+      }, 1e4);
+      void launcherCompletion.then((error) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(forceTimeout);
+        complete(error);
+      });
+    });
+    const waitForResumeAcknowledgment = () => new Promise((complete) => {
+      const forceTimeout = setTimeout(() => {
+        const error = new Error("Timed out resuming the suspended Studio process.");
+        launcher.kill("SIGKILL");
+        signalResume(error);
+        completeLauncher(error);
+      }, 1e4);
+      void resumeAcknowledgment.then((error) => {
+        clearTimeout(forceTimeout);
+        complete(error);
+      });
+    });
+    const throwWithExactCleanup = async (error) => {
+      if (!identity)
+        throw error;
+      try {
+        await stopWindowsStudio(identity.pid, identity.startedAt);
+      } catch (cleanupError) {
+        throw new Error(`${error.message} Exact Studio cleanup also failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+      }
+      throw error;
+    };
+    const authorize = async () => {
+      if (controlState === "resumed")
+        return;
+      if (controlState !== "pending")
+        throw new Error(`Studio launch cannot be authorized from ${controlState}.`);
+      controlState = "accepting";
+      launcher.stdin.write("MCP_STUDIO_LAUNCH_ACCEPT\n");
+      const error = await waitForResumeAcknowledgment();
+      if (error)
+        await throwWithExactCleanup(error);
+      controlState = "resumed";
+    };
+    const release = async () => {
+      if (controlState === "released")
+        return;
+      if (controlState !== "resumed")
+        throw new Error(`Studio launch cannot be released from ${controlState}.`);
+      controlState = "releasing";
+      launcher.stdin.end("MCP_STUDIO_LAUNCH_COMPLETE\n");
+      const error = await waitForLauncherCompletion("Timed out releasing the authorized Studio process.");
+      if (error)
+        await throwWithExactCleanup(error);
+      controlState = "released";
+    };
+    const abort = async () => {
+      if (controlState === "released")
+        return;
+      if (controlState !== "aborting") {
+        controlState = "aborting";
+        launcher.stdin.end("MCP_STUDIO_LAUNCH_ABORT\n");
+      }
+      const error = await waitForLauncherCompletion("Timed out aborting the owned Studio process.");
+      if (error && identity) {
+        await stopWindowsStudio(identity.pid, identity.startedAt);
+      } else if (error) {
+        throw error;
+      }
+    };
+    const timeout = setTimeout(() => {
+      if (identitySettled)
+        return;
+      identitySettled = true;
+      const failure = initialFailure = new Error("Timed out while capturing the exact Studio process identity.");
+      controlState = "aborting";
+      launcher.stdin.end("MCP_STUDIO_LAUNCH_ABORT\n");
+      void waitForLauncherCompletion("Timed out aborting the Studio identity launcher.").then((completionError) => {
+        if (!identity)
+          reject(completionError ?? failure);
+      });
+    }, 15e3);
+    launcher.stdout.on("data", (chunk) => {
+      if (identitySettled) {
+        controlOutput = (controlOutput + chunk.toString("utf8")).slice(-1024);
+        if (controlOutput.includes("MCP_STUDIO_LAUNCH_RESUMED"))
+          signalResume();
+        return;
+      }
+      stdout += chunk.toString("utf8");
+      if (stdout.length > 1024 * 1024) {
+        const failure = initialFailure = new Error("Studio launcher identity output exceeded 1 MiB.");
+        identitySettled = true;
+        controlState = "aborting";
+        launcher.stdin.end("MCP_STUDIO_LAUNCH_ABORT\n");
+        void waitForLauncherCompletion("Timed out aborting the oversized Studio identity response.").then((completionError) => {
+          if (!identity)
+            reject(completionError ?? failure);
+        });
+        return;
+      }
+      const newline = stdout.indexOf("\n");
+      if (newline < 0)
+        return;
+      identitySettled = true;
+      clearTimeout(timeout);
+      try {
+        const parsed = JSON.parse(stdout.slice(0, newline).trim());
+        const nativePid = Number(parsed.pid);
+        const nativeStartedAt = typeof parsed.started === "string" && /^[1-9]\d*$/u.test(parsed.started) ? parsed.started : void 0;
+        if (!Number.isSafeInteger(nativePid) || nativePid <= 0 || nativeStartedAt === void 0) {
+          throw new Error("PowerShell returned an invalid native Studio process identity.");
+        }
+        identity = { pid: nativePid, startedAt: nativeStartedAt };
+        resolve5({
+          pid: nativePid,
+          nativePid,
+          nativeStartedAt,
+          unref: () => {
+          },
+          authorize,
+          release,
+          abort
+        });
+      } catch (error) {
+        const failure = initialFailure = error instanceof Error ? error : new Error(String(error));
+        controlState = "aborting";
+        launcher.stdin.end("MCP_STUDIO_LAUNCH_ABORT\n");
+        void waitForLauncherCompletion("Timed out aborting the invalid Studio identity response.").then((completionError) => {
+          if (!identity)
+            reject(completionError ?? failure);
+        });
+      }
+    });
+    launcher.stdin.on("error", (error) => {
+      if (!initialFailure)
+        initialFailure = error;
+    });
+    launcher.stderr.on("data", (chunk) => {
+      if (stderr.length <= 1024 * 1024)
+        stderr += chunk.toString("utf8");
+    });
+    launcher.once("error", (error) => {
+      clearTimeout(timeout);
+      signalResume(error);
+      completeLauncher(error);
+      if (!identity)
+        reject(error);
+    });
+    launcher.once("exit", (code) => {
+      clearTimeout(timeout);
+      void (async () => {
+        if (code === 0 && identity && !initialFailure) {
+          if (!resumeSettled)
+            signalResume(new Error("Studio launcher exited before resume acknowledgment."));
+          completeLauncher();
+          return;
+        }
+        let cleanupError;
+        if (identity) {
+          try {
+            await stopWindowsStudio(identity.pid, identity.startedAt);
+          } catch (error2) {
+            cleanupError = error2;
+          }
+        }
+        const detail = initialFailure?.message ?? (stderr.trim() || `PowerShell launcher exited with code ${code}.`);
+        const cleanupDetail = cleanupError ? ` Exact Studio cleanup also failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}` : "";
+        const error = new Error(`${detail}${cleanupDetail}`);
+        signalResume(error);
+        completeLauncher(error);
+        if (!identity)
+          reject(error);
+      })();
+    });
+  });
 }
 function resolveEntrypointDir() {
   const entrypoint = process.argv[1];
@@ -3576,7 +4308,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 +4319,7 @@ function isProcessAlive(pid) {
 function sweepStaleBaseplateFiles() {
   let entries;
   try {
-    entries = readdirSync2(BASEPLATE_TEMP_DIR);
+    entries = readdirSync(BASEPLATE_TEMP_DIR);
   } catch {
     return;
   }
@@ -3596,18 +4328,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 +4356,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 +4383,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 +4498,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, retainedLaunchControls, execFileAsync, ENVIRONMENT_VARIABLE_NAME, STALE_BASEPLATE_MAX_AGE_MS, BASEPLATE_TEMP_SWEEP_NAME, LAUNCH_COMPLETION_TIMEOUT_MS, StudioInstanceManager;
 var init_studio_instance_manager = __esm({
   "../core/dist/studio-instance-manager.js"() {
     "use strict";
@@ -3751,27 +4512,45 @@ 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";
+    retainedLaunchControls = /* @__PURE__ */ new Map();
+    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)?$/;
+    LAUNCH_COMPLETION_TIMEOUT_MS = 3 * 60 * 1e3;
     StudioInstanceManager = class {
       managedByInstanceId = /* @__PURE__ */ new Map();
       pending = /* @__PURE__ */ new Set();
-      monitors = /* @__PURE__ */ new Map();
       connectionTimers = /* @__PURE__ */ new Map();
+      launchCompletionTimers = /* @__PURE__ */ new Map();
+      launchControls = retainedLaunchControls;
       registry;
       processAdapter;
+      confirmedExitMisses;
+      confirmedExitGraceMs;
+      snapshotCacheMs;
+      launchCompletionTimeoutMs;
+      coordinatorTimer;
+      coordinatorRefresh;
+      cachedSnapshot;
+      snapshotInFlight;
+      launchQueue = Promise.resolve();
       constructor(options = {}) {
         this.registry = options.registry ?? new ManagedInstanceRegistry(options.registryDir);
         this.processAdapter = options.processAdapter ?? {};
-      }
-      list() {
-        this.sweepRegistry();
+        this.confirmedExitMisses = options.confirmedExitMisses ?? 2;
+        this.confirmedExitGraceMs = options.confirmedExitGraceMs ?? 5e3;
+        this.snapshotCacheMs = options.snapshotCacheMs ?? 0;
+        this.launchCompletionTimeoutMs = options.launchCompletionTimeoutMs ?? LAUNCH_COMPLETION_TIMEOUT_MS;
+      }
+      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 +4559,86 @@ 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;
+      }
+      peekByLaunchId(launchId) {
+        return [...this.managedByInstanceId.values(), ...this.pending].find((record) => record.recordId === launchId);
+      }
+      async authorizeByLaunchId(launchId) {
+        const record = this.peekByLaunchId(launchId);
+        if (!record)
+          throw new Error(`Launch ${launchId} is not retained by this broker process.`);
+        if (record.closedAt !== void 0 || record.state === "failed" || record.state === "exited") {
+          throw new Error(`Launch ${launchId} is no longer eligible for process authorization.`);
+        }
+        if (record.processAuthorizationState === "authorized")
+          return record;
+        const control = this.launchControls.get(launchId);
+        if (record.processAuthorizationState !== "pending" || !control) {
+          throw new Error(`Launch ${launchId} has no retained process authorization handle.`);
+        }
+        try {
+          this.armLaunchCompletionTimer(record);
+          await control.authorize();
+          record.processAuthorizationState = "authorized";
+          await this.persist(record);
+          this.armLaunchCompletionTimer(record);
+          return record;
+        } catch (error) {
+          record.processAuthorizationState = "pending";
+          const detail = error instanceof Error ? error.message : String(error);
+          await this.markFailed(record, `Studio process authorization failed: ${detail}`);
+          throw error;
+        }
+      }
+      async completeByLaunchId(launchId) {
+        const record = this.peekByLaunchId(launchId);
+        if (!record)
+          throw new Error(`Launch ${launchId} is not retained by this broker process.`);
+        if (record.closedAt !== void 0 || record.state === "failed" || record.state === "exited") {
+          throw new Error(`Launch ${launchId} is no longer eligible for ownership release.`);
+        }
+        if (record.processAuthorizationState === "released")
+          return record;
+        const control = this.launchControls.get(launchId);
+        if (record.processAuthorizationState !== "authorized" || !control) {
+          throw new Error(`Launch ${launchId} has no authorized ownership handle to release.`);
+        }
+        try {
+          this.clearLaunchCompletionTimer(record);
+          await control.release();
+          record.processAuthorizationState = "released";
+          this.launchControls.delete(launchId);
+          await this.persist(record);
+          return record;
+        } catch (error) {
+          const detail = error instanceof Error ? error.message : String(error);
+          await this.markFailed(record, `Studio process ownership release failed: ${detail}`);
+          throw error;
+        }
       }
-      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 +4646,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 +4659,75 @@ 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);
-        if (record.closedAt !== void 0 || record.state !== "launching")
+      async markFailed(record, reason) {
+        if (record.closedAt !== void 0 || record.state === "failed" || record.state === "exited")
           return record;
         record.state = "failed";
         record.failedAt = Date.now();
         record.failureReason = reason;
         this.clearConnectionTimer(record);
-        this.persist(record);
+        this.clearLaunchCompletionTimer(record);
+        const control = record.recordId ? this.launchControls.get(record.recordId) : void 0;
+        if (record.processAuthorizationState !== "released" && control) {
+          try {
+            await control.abort();
+            const exitedAt = Date.now();
+            record.exitedAt = exitedAt;
+            record.closedAt = exitedAt;
+            record.processObservationStatus = "not_running";
+            record.lastProcessObservationAt = exitedAt;
+            record.lastSuccessfulProcessObservationAt = exitedAt;
+            this.cleanupManagedRecord(record);
+            this.markClosedInMemory(record);
+          } catch (error) {
+            record.failureReason += ` Exact suspended-process cleanup also failed: ${error instanceof Error ? error.message : String(error)}`;
+          }
+        }
+        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);
+          return this.markFailed(record, "Studio launched, but the MCP plugin did not connect before timeout.");
         }
         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.");
         }
+        if (options.requireProcessIdentity && !this.processAdapter.spawnStudio && process.platform !== "win32" && !isWsl()) {
+          throw new Error("require_process_identity is supported only by the identity-retaining Windows launcher or a custom process adapter.");
+        }
         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 +4737,9 @@ var init_studio_instance_manager = __esm({
         let proc;
         try {
           if (this.processAdapter.spawnStudio) {
-            proc = this.processAdapter.spawnStudio(exe, args, spawnOptions);
-          } else if (isWsl()) {
-            proc = spawnWindowsStudioFromWsl(exe, args, processEnvironment);
+            proc = await this.processAdapter.spawnStudio(exe, args, spawnOptions);
+          } else if (process.platform === "win32" || isWsl()) {
+            proc = await spawnWindowsStudio(exe, args, processEnvironment);
           } else {
             const child = spawn(exe, args, spawnOptions);
             proc = {
@@ -3891,8 +4758,40 @@ var init_studio_instance_manager = __esm({
           cleanupManagedBaseplateFiles({ source: preparedOptions.source, localPlaceFile: preparedOptions.localPlaceFile });
           throw error;
         }
+        if (options.requireProcessIdentity && (!Number.isSafeInteger(proc.nativePid) || (proc.nativePid ?? 0) <= 0 || proc.nativeStartedAt === void 0 || !/^[1-9]\d*$/u.test(proc.nativeStartedAt) || !proc.authorize || !proc.release || !proc.abort)) {
+          const reason = "Studio launcher did not return an exact creation identity and suspended-process control handles.";
+          let abortError;
+          try {
+            if (proc.abort) {
+              await proc.abort();
+            } else if (proc.nativePid && proc.nativeStartedAt) {
+              await this.closeProcess(proc.nativePid, proc.nativeStartedAt);
+            } else {
+              throw new Error("the process adapter did not retain an abort handle or exact process identity");
+            }
+          } catch (error) {
+            abortError = error;
+          }
+          cleanupManagedBaseplateFiles({ source: preparedOptions.source, localPlaceFile: preparedOptions.localPlaceFile });
+          const abortDetail = abortError ? ` Exact child cleanup also failed: ${abortError instanceof Error ? abortError.message : String(abortError)}` : " The owned process was stopped.";
+          throw new Error(`${reason}${abortDetail}`);
+        }
+        if (!options.requireProcessIdentity && proc.authorize) {
+          try {
+            await proc.authorize();
+            await proc.release?.();
+          } catch (error) {
+            try {
+              await proc.abort?.();
+            } finally {
+              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,26 +4802,41 @@ 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: options.requireProcessIdentity ? void 0 : launchedAt + (options.connectionTimeoutMs ?? 12e4),
           state: "launching",
           ownerPid: process.pid,
           bootId,
-          deleteLocalPlaceFileOnClose: options.source === "baseplate"
+          deleteLocalPlaceFileOnClose: options.source === "baseplate",
+          processAuthorizationState: options.requireProcessIdentity && proc.authorize && proc.release ? "pending" : "released",
+          processObservationStatus: "running",
+          lastProcessObservationAt: launchedAt,
+          lastSuccessfulProcessObservationAt: launchedAt,
+          consecutiveConfirmedMisses: 0
         };
         this.pending.add(record);
         try {
-          this.persist(record);
+          await this.persist(record);
+          if (record.recordId && record.processAuthorizationState === "pending" && proc.authorize && proc.release && proc.abort) {
+            this.launchControls.set(record.recordId, {
+              authorize: proc.authorize,
+              release: proc.release,
+              abort: proc.abort
+            });
+            this.armLaunchCompletionTimer(record);
+          }
         } catch (error) {
           this.pending.delete(record);
           const processId = record.nativeProcessId ?? record.spawnPid;
           let stopError;
-          if (processId) {
-            try {
-              this.closeProcess(processId);
-            } catch (caught) {
-              stopError = caught;
+          try {
+            if (proc.abort) {
+              await proc.abort();
+            } else if (processId) {
+              await this.closeProcess(processId, record.nativeProcessStartedAt);
             }
+          } catch (caught) {
+            stopError = caught;
           }
           cleanupManagedBaseplateFiles(record);
           const detail = error instanceof Error ? error.message : String(error);
@@ -3931,38 +4845,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 +4886,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,46 +4910,69 @@ 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 };
+          return {
+            status: "already_closed",
+            launchId: record.recordId,
+            instanceId: record.instanceId
+          };
         }
         const processId = record.nativeProcessId ?? record.spawnPid;
         if (!processId) {
           throw new Error(`Cannot close ${record.instanceId ?? "Studio launch"} because its process id was not detected.`);
         }
-        const studioProcess = this.findProcessById(processId);
-        if (!studioProcess) {
+        const control = record.recordId ? this.launchControls.get(record.recordId) : void 0;
+        if (record.processAuthorizationState !== "released" && control) {
+          await control.abort();
+          const closedAt2 = Date.now();
+          record.closedAt = closedAt2;
+          record.exitedAt = closedAt2;
+          if (record.state !== "failed")
+            record.state = "exited";
+          record.processObservationStatus = "not_running";
+          record.lastProcessObservationAt = closedAt2;
+          record.lastSuccessfulProcessObservationAt = closedAt2;
+          record.lastProcessObservationError = void 0;
           this.cleanupManagedRecord(record);
-          this.markProcessExited(record, void 0, record.failureReason);
-          this.registry.logEvent({
+          this.markClosedInMemory(record);
+          await this.persist(record);
+          return {
+            status: "closed",
+            launchId: record.recordId,
+            instanceId: record.instanceId
+          };
+        }
+        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") {
+          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.");
+          return {
+            status: "already_closed",
+            launchId: record.recordId,
+            instanceId: record.instanceId
+          };
         }
         try {
-          this.closeProcess(processId);
+          await this.closeProcess(processId, record.nativeProcessStartedAt);
         } 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,
@@ -4041,34 +4980,52 @@ var init_studio_instance_manager = __esm({
             reason: "stop_raced_with_exit",
             action: "marked_closed_and_cleaned_baseplate"
           });
-          this.cleanupManagedRecord(record);
-          this.markProcessExited(record, void 0, record.failureReason);
-          return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
+          await this.markProcessExited(record, void 0, record.failureReason);
+          return {
+            status: "already_closed",
+            launchId: record.recordId,
+            instanceId: record.instanceId
+          };
         }
         const closedAt = Date.now();
         record.closedAt = closedAt;
         record.exitedAt = record.exitedAt ?? closedAt;
         if (record.state !== "failed")
           record.state = "exited";
+        record.processObservationStatus = "not_running";
+        record.lastProcessObservationAt = closedAt;
+        record.lastSuccessfulProcessObservationAt = closedAt;
+        record.lastProcessObservationError = void 0;
         this.cleanupManagedRecord(record);
         this.markClosedInMemory(record);
-        this.persist(record);
-        return { status: "closed", launchId: record.recordId, instanceId: record.instanceId };
+        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, process2.StartTimeUtcFileTime);
       }
-      closeProcess(processId) {
+      async closeProcess(processId, startedAt) {
         if (this.processAdapter.stopProcess) {
-          this.processAdapter.stopProcess(processId);
+          await this.processAdapter.stopProcess(processId, startedAt);
           return;
         }
         if (process.platform === "win32" || isWsl()) {
-          powershell(`Stop-Process -Id ${Math.trunc(processId)} -Force -ErrorAction Stop`);
+          if (startedAt === void 0) {
+            throw new Error("Cannot stop a Windows Studio process without its creation-time identity.");
+          }
+          await stopWindowsStudio(processId, startedAt);
         } else {
           try {
             process.kill(processId, "SIGTERM");
@@ -4078,8 +5035,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 +5054,109 @@ 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) => {
+            if (record.processAuthorizationState !== "released" && this.launchControls.has(record.recordId))
+              return;
+            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) {
+        const sweepOptions = await this.registrySweepOptions(snapshot);
+        await this.registry.sweep(sweepOptions);
+        const persisted = await this.registry.listOpenUnchecked();
+        for (const registryRecord of persisted) {
+          const ownerPid = registryRecord.ownerPid;
+          if (registryRecord.processAuthorizationState === "released" || this.launchControls.has(registryRecord.recordId) || registryRecord.bootId !== sweepOptions.currentBootId || ownerPid === void 0 || ownerPid !== process.pid && isProcessAlive2(ownerPid)) {
+            continue;
+          }
+          const record = this.fromRegistryRecord(registryRecord);
+          if (this.observeRecord(record, snapshot).status !== "running")
+            continue;
+          const processId = record.nativeProcessId ?? record.spawnPid;
+          if (!processId || !record.nativeProcessStartedAt) {
+            record.state = "failed";
+            record.failedAt = Date.now();
+            record.failureReason = "Orphaned unreleased Studio launch has no exact process identity for cleanup.";
+            await this.persist(record);
+            continue;
+          }
+          try {
+            await this.closeProcess(processId, record.nativeProcessStartedAt);
+            const closedAt = Date.now();
+            record.state = "failed";
+            record.failedAt = closedAt;
+            record.failureReason = "Orphaned unreleased Studio launch was stopped after its broker owner exited.";
+            record.exitedAt = closedAt;
+            record.closedAt = closedAt;
+            record.processObservationStatus = "not_running";
+            record.lastProcessObservationAt = closedAt;
+            record.lastSuccessfulProcessObservationAt = closedAt;
+            this.cleanupManagedRecord(record);
+            await this.persist(record);
+          } catch (error) {
+            record.state = "failed";
+            record.failedAt = Date.now();
+            record.failureReason = `Failed to stop orphaned unreleased Studio launch: ${error instanceof Error ? error.message : String(error)}`;
+            await this.persist(record);
+          }
+        }
       }
-      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();
@@ -4147,62 +5181,104 @@ var init_studio_instance_manager = __esm({
         return false;
       }
       cleanupManagedRecord(record) {
+        if (record.recordId)
+          this.launchControls.delete(record.recordId);
+        if (record.recordId)
+          this.clearLaunchCompletionTimer(record);
         if (record.source !== "baseplate")
           return;
-        cleanupManagedBaseplateFiles({ source: "baseplate", localPlaceFile: record.localPlaceFile });
+        cleanupManagedBaseplateFiles({
+          source: "baseplate",
+          localPlaceFile: record.localPlaceFile
+        });
       }
       markClosedInMemory(record) {
         record.closedAt = record.closedAt ?? Date.now();
         if (record.instanceId)
           this.managedByInstanceId.delete(record.instanceId);
         this.pending.delete(record);
-        this.stopMonitor(record);
+        this.clearConnectionTimer(record);
+        this.clearLaunchCompletionTimer(record);
+      }
+      armLaunchCompletionTimer(record) {
+        if (!record.recordId)
+          return;
+        this.clearLaunchCompletionTimer(record);
+        const timeout = setTimeout(() => {
+          this.runInBackground("aborting an uncompleted Studio launch", this.markFailed(record, "Carbon did not complete Studio launch ownership transfer before timeout."));
+        }, this.launchCompletionTimeoutMs);
+        if (typeof timeout === "object" && "unref" in timeout)
+          timeout.unref();
+        this.launchCompletionTimers.set(record.recordId, timeout);
+      }
+      clearLaunchCompletionTimer(record) {
+        if (!record.recordId)
+          return;
+        const timer = this.launchCompletionTimers.get(record.recordId);
+        clearTimeout(timer);
+        this.launchCompletionTimers.delete(record.recordId);
       }
-      markProcessExited(record, exitCode, reason) {
+      async markProcessExited(record, exitCode, reason) {
         if (record.closedAt !== void 0)
           return record;
+        const control = record.recordId ? this.launchControls.get(record.recordId) : void 0;
+        let controlFailure;
+        if (record.processAuthorizationState !== "released" && control) {
+          try {
+            await control.abort();
+          } catch (error) {
+            controlFailure = error instanceof Error ? error.message : String(error);
+          }
+        }
         const exitedAt = Date.now();
         record.exitedAt = exitedAt;
         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;
+        if (controlFailure) {
+          record.failureReason = [
+            record.failureReason,
+            `Launch ownership cleanup failed: ${controlFailure}`
+          ].filter(Boolean).join(" ");
+        }
         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 +5288,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 +5393,14 @@ var init_studio_instance_manager = __esm({
           failureReason: record.failureReason,
           closedAt: record.closedAt,
           ownerPid: record.ownerPid,
-          bootId: record.bootId
+          bootId: record.bootId,
+          processObservationStatus: record.processObservationStatus,
+          processAuthorizationState: record.processAuthorizationState,
+          lastProcessObservationAt: record.lastProcessObservationAt,
+          lastSuccessfulProcessObservationAt: record.lastSuccessfulProcessObservationAt,
+          lastProcessObservationError: record.lastProcessObservationError,
+          consecutiveConfirmedMisses: record.consecutiveConfirmedMisses,
+          firstConfirmedMissAt: record.firstConfirmedMissAt
         };
       }
       fromRegistryRecord(record) {
@@ -4264,7 +5419,7 @@ var init_studio_instance_manager = __esm({
           placeVersion: record.placeVersion,
           localPlaceFile: record.localPlaceFile,
           launchedAt: record.launchedAt,
-          connectionDeadlineAt: record.connectionDeadlineAt ?? (state === "launching" ? record.launchedAt + 12e4 : void 0),
+          connectionDeadlineAt: record.connectionDeadlineAt ?? (state === "launching" && record.processAuthorizationState === void 0 ? record.launchedAt + 12e4 : void 0),
           state,
           connectedAt: record.attachedAt,
           failedAt: record.failedAt,
@@ -4274,7 +5429,14 @@ var init_studio_instance_manager = __esm({
           closedAt: record.closedAt,
           ownerPid: record.ownerPid,
           bootId: record.bootId,
-          deleteLocalPlaceFileOnClose: record.deleteLocalPlaceFileOnClose
+          deleteLocalPlaceFileOnClose: record.deleteLocalPlaceFileOnClose,
+          processObservationStatus: record.processObservationStatus,
+          processAuthorizationState: record.processAuthorizationState ?? "released",
+          lastProcessObservationAt: record.lastProcessObservationAt,
+          lastSuccessfulProcessObservationAt: record.lastSuccessfulProcessObservationAt,
+          lastProcessObservationError: record.lastProcessObservationError,
+          consecutiveConfirmedMisses: record.consecutiveConfirmedMisses,
+          firstConfirmedMissAt: record.firstConfirmedMissAt
         };
       }
     };
@@ -5085,7 +6247,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 +6459,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 +6473,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 +6481,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 +6495,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 +8223,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) }] };
@@ -7384,7 +8553,8 @@ var init_tools = __esm({
         if (typeof state !== "object" || state === null || Array.isArray(state)) {
           return state;
         }
-        const { devices: _devices, ...rest } = state;
+        const rest = { ...state };
+        delete rest.devices;
         return rest;
       }
       _assertCanRestoreDeviceSimulatorState(state) {
@@ -8313,7 +9483,8 @@ ${code}`
             };
             entrySummaries.push(entrySummary);
             try {
-              const { label: _label, ...settings } = entry;
+              const settings = { ...entry };
+              delete settings.label;
               const applied = await this._executeDeviceSimulatorOperation(resolved.instanceId, resolved.role, "set", { settings });
               entrySummary.applied = applied;
               if (settleMs > 0)
@@ -8648,9 +9819,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 +9833,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 +9855,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 +9867,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 +9874,15 @@ ${code}`
           managed: true,
           state: record.state,
           pid: record.nativeProcessId ?? record.spawnPid,
-          process_running: record.closedAt === void 0 && record.exitedAt === void 0,
+          process_started_at_file_time: record.nativeProcessStartedAt,
+          process_authorized: record.processAuthorizationState !== "pending",
+          process_ownership_released: record.processAuthorizationState === "released",
+          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,
@@ -8730,8 +9908,8 @@ ${code}`
         if (instance_id && launch_id) {
           throw new Error("manage_instance accepts only one of instance_id or launch_id.");
         }
-        if (action !== "launch" && action !== "close" && action !== "status" && action !== "list_place_versions") {
-          throw new Error("manage_instance requires action=launch|close|status|list_place_versions");
+        if (action !== "launch" && action !== "authorize" && action !== "complete" && action !== "close" && action !== "status" && action !== "list_place_versions") {
+          throw new Error("manage_instance requires action=launch|authorize|complete|close|status|list_place_versions");
         }
         if (action === "list_place_versions") {
           if (!this.openCloudClient.hasApiKey()) {
@@ -8756,15 +9934,30 @@ ${code}`
             body.next_page_token = response.nextPageToken;
           return this._textResult(body);
         }
+        if (action === "close" || action === "status") {
+          await this.managedConnectionAssociations;
+        }
+        if (action === "authorize") {
+          if (!launch_id)
+            throw new Error("manage_instance action=authorize requires launch_id.");
+          const record2 = await this.instanceManager.authorizeByLaunchId(launch_id);
+          return this._textResult(this._managedStatus(record2));
+        }
+        if (action === "complete") {
+          if (!launch_id)
+            throw new Error("manage_instance action=complete requires launch_id.");
+          const record2 = await this.instanceManager.completeByLaunchId(launch_id);
+          return this._textResult(this._managedStatus(record2));
+        }
         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 +9974,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 +9986,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 +10003,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 +10025,7 @@ ${code}`
               });
             }
             try {
-              this.instanceManager.closeConnectedInstance(edit);
+              await this.instanceManager.closeConnectedInstance(edit);
               await sleep(500);
             } catch (error) {
               return this._textResult({
@@ -8847,7 +10040,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 +10054,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,14 +10081,18 @@ ${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.`
           });
         }
         const universeId = launchSource === "published_place" || launchSource === "place_revision" ? await this._deriveUniverseId(placeId) : void 0;
-        const waitForConnection = request.wait_for_connection !== false;
+        if (request.require_process_identity !== void 0 && typeof request.require_process_identity !== "boolean") {
+          throw new Error("require_process_identity must be a boolean when provided.");
+        }
+        const requireProcessIdentity = request.require_process_identity === true;
+        const waitForConnection = !requireProcessIdentity && request.wait_for_connection !== false;
         const timeoutMs = this._optionalPositiveInteger(request.timeout_ms, "timeout_ms") ?? 12e4;
         const beforeKeys = new Set(this.bridge.getPublicInstances().map((instance) => this._publicInstanceKey(instance)));
         const record = await this.instanceManager.launch({
@@ -8906,7 +10103,8 @@ ${code}`
           placeVersion,
           connectionTimeoutMs: timeoutMs,
           studioExecutable,
-          processEnvironment
+          processEnvironment,
+          ...requireProcessIdentity ? { requireProcessIdentity: true } : {}
         });
         if (!waitForConnection) {
           return this._textResult({
@@ -8917,11 +10115,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 +10128,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."
@@ -10203,11 +11401,15 @@ ${code}`
       }
       async uploadGenerateModelReferenceImage(imageContent, instance_id) {
         if (this.cookieClient.hasCookie()) {
-          const result2 = await this.cookieClient.uploadDecal(imageContent, STUDIO_ASSISTANT_SOURCE_IMAGE_LABEL, STUDIO_ASSISTANT_SOURCE_IMAGE_LABEL);
-          if (result2.backingAssetId && result2.backingAssetId > 0) {
-            return result2.backingAssetId;
-          }
-          return this.resolveUploadedReferenceImageId(String(result2.assetId), instance_id);
+          const result2 = await this.cookieClient.uploadImage({
+            fileContent: imageContent,
+            fileName: "generate-model-reference.png",
+            displayName: STUDIO_ASSISTANT_SOURCE_IMAGE_LABEL,
+            description: STUDIO_ASSISTANT_SOURCE_IMAGE_LABEL,
+            userId: process.env.ROBLOX_CREATOR_USER_ID,
+            groupId: process.env.ROBLOX_CREATOR_GROUP_ID
+          });
+          return result2.assetId;
         }
         if (!this.openCloudClient.hasApiKey()) {
           throw new Error("image_path and image_base64 require Roblox asset upload credentials because GenerateModelAsync only accepts rbxassetid:// or rbxasset:// image inputs. Set ROBLOX_OPEN_CLOUD_API_KEY plus ROBLOX_CREATOR_USER_ID or ROBLOX_CREATOR_GROUP_ID, or pass image_asset_id.");
@@ -10241,8 +11443,17 @@ ${code}`
         }
         const fileContent = fs3.readFileSync(filePath);
         const fileName = path5.basename(filePath);
+        const resolvedGroupId = groupId || process.env.ROBLOX_CREATOR_GROUP_ID;
+        const resolvedUserId = userId || process.env.ROBLOX_CREATOR_USER_ID;
         if (assetType === "Decal" && this.cookieClient.hasCookie()) {
-          const result2 = await this.cookieClient.uploadDecal(fileContent, displayName, description || "");
+          const result2 = await this.cookieClient.uploadImage({
+            fileContent,
+            fileName,
+            displayName,
+            description: description || "",
+            userId: resolvedUserId,
+            groupId: resolvedGroupId
+          });
           return {
             content: [{
               type: "text",
@@ -10251,9 +11462,9 @@ ${code}`
                 response: {
                   assetId: String(result2.assetId),
                   displayName,
-                  assetType,
-                  decalId: String(result2.assetId),
-                  imageId: String(result2.backingAssetId)
+                  assetType: "Image",
+                  decalId: null,
+                  imageId: String(result2.assetId)
                 }
               })
             }]
@@ -10263,8 +11474,6 @@ ${code}`
           const cookieHint = assetType === "Decal" ? " Alternatively, set ROBLOSECURITY to use cookie auth." : "";
           throw new Error(`No auth configured for ${assetType} upload. Set ROBLOX_OPEN_CLOUD_API_KEY (needs asset:write scope).${cookieHint}`);
         }
-        const resolvedGroupId = groupId || process.env.ROBLOX_CREATOR_GROUP_ID;
-        const resolvedUserId = userId || process.env.ROBLOX_CREATOR_USER_ID;
         if (!resolvedUserId && !resolvedGroupId) {
           throw new Error("Creator identity required for Open Cloud upload. Set ROBLOX_CREATOR_USER_ID or ROBLOX_CREATOR_GROUP_ID, or pass userId/groupId as parameters.");
         }
@@ -11929,14 +13138,14 @@ var init_definitions = __esm({
       {
         name: "manage_instance",
         category: "write",
-        description: 'Launch, close, inspect, and find revisions for Studio instances. Every launch returns launch_id, native pid, source, and lifecycle state; status and close accept launch_id before the plugin connects and instance_id after association. Use action="launch" with source="baseplate" for a blank place, or source="local_file" with local_place_file for a local place; neither uses place_id. Use action="list_place_versions" with place_id to retrieve version numbers through Open Cloud asset versions, then action="launch" with source="place_revision", place_id, and place_version to open an older revision. action="launch" source="published_place" opens the latest published place and is blocked if that place_id is already connected; source="place_revision" is allowed because Studio opens explicit past revisions as anonymous local copies. Requires ROBLOX_OPEN_CLOUD_API_KEY with asset:read for list_place_versions.',
+        description: 'Launch, authorize, complete, close, inspect, and find revisions for Studio instances. Every launch returns launch_id, native pid, source, and lifecycle state; status and close accept launch_id before the plugin connects and instance_id after association. Use action="launch" with source="baseplate" for a blank place, or source="local_file" with local_place_file for a local place; neither uses place_id. A process-identity launch requires action="authorize" after injection is prepared, followed by action="complete" only after the injected runtime is independently attested. Use action="list_place_versions" with place_id to retrieve version numbers through Open Cloud asset versions, then action="launch" with source="place_revision", place_id, and place_version to open an older revision. action="launch" source="published_place" opens the latest published place and is blocked if that place_id is already connected; source="place_revision" is allowed because Studio opens explicit past revisions as anonymous local copies. Requires ROBLOX_OPEN_CLOUD_API_KEY with asset:read for list_place_versions.',
         inputSchema: {
           type: "object",
           properties: {
             action: {
               type: "string",
-              enum: ["launch", "close", "status", "list_place_versions"],
-              description: "Instance management action."
+              enum: ["launch", "authorize", "complete", "close", "status", "list_place_versions"],
+              description: "Instance management action. authorize resumes a protocol-v3 launch after the caller has prepared process-scoped injection. complete releases broker process ownership after the caller independently attests that injection finished."
             },
             source: {
               type: "string",
@@ -11955,13 +13164,17 @@ var init_definitions = __esm({
               type: "number",
               description: 'Required for source="place_revision". Use action="list_place_versions" to discover available version numbers.'
             },
+            require_process_identity: {
+              type: "boolean",
+              description: 'For action="launch": require an exact native PID and process creation time, return launch_id immediately, and retain broker ownership of the native process until action="complete" succeeds. The process remains suspended until action="authorize" begins injection. If identity capture, authorization, or ownership completion fails, the broker stops the launched process.'
+            },
             wait_for_connection: {
               type: "boolean",
-              description: 'For action="launch": wait until the MCP plugin connects and return instance_id (default true). false returns launch_id immediately and continues association/failure tracking asynchronously.'
+              description: 'For action="launch": wait until the MCP plugin connects and return instance_id (default true). false returns launch_id immediately and continues association/failure tracking asynchronously. Ignored when require_process_identity=true, which always returns the suspended launch immediately.'
             },
             timeout_ms: {
               type: "number",
-              description: 'For action="launch": max milliseconds for plugin connection (default 120000). The deadline also applies asynchronously when wait_for_connection=false.'
+              description: 'For action="launch": max milliseconds for plugin connection (default 120000). The deadline also applies asynchronously when wait_for_connection=false. It does not apply when require_process_identity=true; that protocol uses the broker ownership-completion lease through action="complete".'
             },
             studio_executable: {
               type: "string",
@@ -13182,7 +14395,7 @@ part(0,2,0,2,1,1,"b")`,
       {
         name: "upload_asset",
         category: "write",
-        description: "Upload any supported asset type to Roblox: Audio (mp3/ogg/wav/flac), Decal (png/jpg/bmp/tga), Model (fbx/gltf/glb/rbxm/rbxmx), Animation (rbxm/rbxmx), or Video (mp4/mov). Decal supports ROBLOSECURITY cookie auth or ROBLOX_OPEN_CLOUD_API_KEY. All other types require Open Cloud API key with asset:write scope + creator ID. Audio: max 7 min, 100 uploads/month (ID-verified). Video: max 5 min, requires 13+ ID-verified.",
+        description: "Upload any supported asset type to Roblox: Audio (mp3/ogg/wav/flac), Decal (png/jpg/bmp/tga), Model (fbx/gltf/glb/rbxm/rbxmx), Animation (rbxm/rbxmx), or Video (mp4/mov). Decal supports ROBLOSECURITY cookie auth through the Asset Manager user-auth API and returns the direct Image asset ID, or ROBLOX_OPEN_CLOUD_API_KEY. All other types require Open Cloud API key with asset:write scope + creator ID. Audio: max 7 min, 100 uploads/month (ID-verified). Video: max 5 min, requires 13+ ID-verified.",
         inputSchema: {
           type: "object",
           properties: {
@@ -13788,7 +15001,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 +15009,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 +15094,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 +15156,7 @@ function prepareInstall({
 }) {
   const pluginsFolder = getPluginsFolder();
   if (!existsSync7(pluginsFolder)) {
-    mkdirSync5(pluginsFolder, { recursive: true });
+    mkdirSync4(pluginsFolder, { recursive: true });
   }
   handleVariantConflict({
     pluginsFolder,
@@ -13964,14 +15177,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 +15198,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 = {}) {