@chrrxs/robloxstudio-mcp-inspector 2.22.4 → 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) {
@@ -3121,7 +3211,7 @@ function isProcessAlive(pid) {
     return error.code === "EPERM";
   }
 }
-var REGISTRY_VERSION, LOCK_STALE_MS, LOCK_RETRY_MS, LOCK_TIMEOUT_MS, EVENT_RETENTION_DAYS, TERMINAL_RECORD_RETENTION_MS, DEFAULT_CONFIRMED_EXIT_MISSES, DEFAULT_CONFIRMED_EXIT_GRACE_MS, activeLockTokens, ManagedInstanceRegistry;
+var 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";
@@ -3134,6 +3224,7 @@ var init_managed_instance_registry = __esm({
     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()) {
@@ -3208,6 +3299,7 @@ var init_managed_instance_registry = __esm({
           try {
             await fs.mkdir(lockDir);
             activeLockTokens.add(owner.token);
+            activeLockPaths.add(lockDir);
             try {
               await fs.writeFile(path.join(lockDir, "owner.json"), `${JSON.stringify(owner)}
 `, {
@@ -3216,6 +3308,7 @@ var init_managed_instance_registry = __esm({
               });
             } catch (error) {
               activeLockTokens.delete(owner.token);
+              activeLockPaths.delete(lockDir);
               await fs.rm(lockDir, { recursive: true, force: true });
               throw error;
             }
@@ -3228,7 +3321,7 @@ var init_managed_instance_registry = __esm({
               const stat2 = await fs.stat(lockDir);
               const currentOwner = await this.readLockOwner(lockDir, stat2.isDirectory());
               const ownerIsActive = currentOwner?.pid === process.pid ? activeLockTokens.has(currentOwner.token) : currentOwner ? isProcessAlive(currentOwner.pid) : void 0;
-              if (ownerIsActive === false || currentOwner === void 0 && Date.now() - stat2.mtimeMs > LOCK_STALE_MS) {
+              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;
               }
@@ -3253,6 +3346,7 @@ var init_managed_instance_registry = __esm({
           } catch {
           } finally {
             activeLockTokens.delete(owner.token);
+            activeLockPaths.delete(lockDir);
           }
         }
       }
@@ -3638,39 +3732,554 @@ function quoteWindowsCommandLineArg(value) {
 }
 function buildWindowsStudioStartScriptFromConvertedExe(windowsExe, args, processEnvironment) {
   const environmentPatch = parseStudioProcessEnvironmentPatch(processEnvironment);
-  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 the PowerShell invocation waiting until Studio exits even though
-    // PowerShell already printed the PID. Shell execution prevents that
-    // inheritance while Process.Start still returns the native Studio PID.
-    "$psi.UseShellExecute = $true",
-    "$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("; ");
 }
-async function spawnWindowsStudioFromWsl(exe, args, processEnvironment) {
+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 output = await powershellAsync(`${script}; [PSCustomObject]@{ pid = $studio.Id; started = $studio.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() } | ConvertTo-Json -Compress`);
-  const parsed = JSON.parse(output);
-  const nativePid = Number(parsed.pid);
-  const nativeStartedAt = typeof parsed.started === "string" && /^\d+$/u.test(parsed.started) ? parsed.started : void 0;
-  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: () => {
-    }
-  };
+  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];
@@ -3895,7 +4504,7 @@ function delay2(ms) {
 function basenameAny(filePath) {
   return path2.basename(filePath.replace(/\\/g, "/"));
 }
-var BASEPLATE_TEMP_DIR, BASEPLATE_TEMP_NAME, BASEPLATE_TEMPLATE_NAME, execFileAsync, ENVIRONMENT_VARIABLE_NAME, STALE_BASEPLATE_MAX_AGE_MS, BASEPLATE_TEMP_SWEEP_NAME, StudioInstanceManager;
+var 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";
@@ -3903,19 +4512,24 @@ 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();
       connectionTimers = /* @__PURE__ */ new Map();
+      launchCompletionTimers = /* @__PURE__ */ new Map();
+      launchControls = retainedLaunchControls;
       registry;
       processAdapter;
       confirmedExitMisses;
       confirmedExitGraceMs;
       snapshotCacheMs;
+      launchCompletionTimeoutMs;
       coordinatorTimer;
       coordinatorRefresh;
       cachedSnapshot;
@@ -3927,6 +4541,7 @@ var init_studio_instance_manager = __esm({
         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();
@@ -3962,6 +4577,62 @@ var init_studio_instance_manager = __esm({
         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;
+        }
+      }
       async pendingLaunches() {
         const now = Date.now();
         const bootId = await this.getCurrentBootId();
@@ -3991,12 +4662,29 @@ var init_studio_instance_manager = __esm({
         await this.persist(record);
       }
       async markFailed(record, reason) {
-        if (record.closedAt !== void 0 || record.state !== "launching")
+        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.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;
       }
@@ -4008,11 +4696,7 @@ var init_studio_instance_manager = __esm({
         if (record.closedAt !== void 0)
           return record;
         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);
-          await this.persist(record);
+          return this.markFailed(record, "Studio launched, but the MCP plugin did not connect before timeout.");
         }
         return record;
       }
@@ -4036,6 +4720,9 @@ var init_studio_instance_manager = __esm({
         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 = await this.getCurrentBootId();
         const before = new Set(initialSnapshot.status === "ok" ? initialSnapshot.processes.map((proc2) => proc2.Id) : []);
@@ -4051,8 +4738,8 @@ var init_studio_instance_manager = __esm({
         try {
           if (this.processAdapter.spawnStudio) {
             proc = await this.processAdapter.spawnStudio(exe, args, spawnOptions);
-          } else if (isWsl()) {
-            proc = await spawnWindowsStudioFromWsl(exe, args, processEnvironment);
+          } else if (process.platform === "win32" || isWsl()) {
+            proc = await spawnWindowsStudio(exe, args, processEnvironment);
           } else {
             const child = spawn(exe, args, spawnOptions);
             proc = {
@@ -4071,6 +4758,37 @@ 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: randomUUID2(),
@@ -4085,11 +4803,12 @@ var init_studio_instance_manager = __esm({
           placeVersion: preparedOptions.placeVersion,
           localPlaceFile: preparedOptions.localPlaceFile,
           launchedAt,
-          connectionDeadlineAt: launchedAt + (options.connectionTimeoutMs ?? 12e4),
+          connectionDeadlineAt: options.requireProcessIdentity ? void 0 : launchedAt + (options.connectionTimeoutMs ?? 12e4),
           state: "launching",
           ownerPid: process.pid,
           bootId,
           deleteLocalPlaceFileOnClose: options.source === "baseplate",
+          processAuthorizationState: options.requireProcessIdentity && proc.authorize && proc.release ? "pending" : "released",
           processObservationStatus: "running",
           lastProcessObservationAt: launchedAt,
           lastSuccessfulProcessObservationAt: launchedAt,
@@ -4098,16 +4817,26 @@ var init_studio_instance_manager = __esm({
         this.pending.add(record);
         try {
           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 {
-              await 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);
@@ -4183,12 +4912,37 @@ var init_studio_instance_manager = __esm({
       }
       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 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.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") {
@@ -4196,7 +4950,6 @@ var init_studio_instance_manager = __esm({
           throw new Error(`Cannot verify the managed Studio process because process observation failed: ${observation.error}`);
         }
         if (observation.status === "not_running") {
-          this.cleanupManagedRecord(record);
           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",
@@ -4206,10 +4959,14 @@ var init_studio_instance_manager = __esm({
             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 };
+          return {
+            status: "already_closed",
+            launchId: record.recordId,
+            instanceId: record.instanceId
+          };
         }
         try {
-          await this.closeProcess(processId);
+          await this.closeProcess(processId, record.nativeProcessStartedAt);
         } catch (error) {
           const retry = await this.getProcessSnapshot(true);
           const retryObservation = this.observeRecord(record, retry);
@@ -4223,9 +4980,12 @@ var init_studio_instance_manager = __esm({
             reason: "stop_raced_with_exit",
             action: "marked_closed_and_cleaned_baseplate"
           });
-          this.cleanupManagedRecord(record);
           await this.markProcessExited(record, void 0, record.failureReason);
-          return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
+          return {
+            status: "already_closed",
+            launchId: record.recordId,
+            instanceId: record.instanceId
+          };
         }
         const closedAt = Date.now();
         record.closedAt = closedAt;
@@ -4239,7 +4999,11 @@ var init_studio_instance_manager = __esm({
         this.cleanupManagedRecord(record);
         this.markClosedInMemory(record);
         await this.persist(record);
-        return { status: "closed", launchId: record.recordId, instanceId: record.instanceId };
+        return {
+          status: "closed",
+          launchId: record.recordId,
+          instanceId: record.instanceId
+        };
       }
       async closeConnectedInstance(instance) {
         const snapshot = await this.getProcessSnapshot(true);
@@ -4250,15 +5014,18 @@ var init_studio_instance_manager = __esm({
         if (!process2) {
           throw new Error(`Could not find a Studio process for connected instance "${instance.instanceId}".`);
         }
-        await this.closeProcess(process2.Id);
+        await this.closeProcess(process2.Id, process2.StartTimeUtcFileTime);
       }
-      async closeProcess(processId) {
+      async closeProcess(processId, startedAt) {
         if (this.processAdapter.stopProcess) {
-          await this.processAdapter.stopProcess(processId);
+          await this.processAdapter.stopProcess(processId, startedAt);
           return;
         }
         if (process.platform === "win32" || isWsl()) {
-          await powershellAsync(`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");
@@ -4329,13 +5096,55 @@ var init_studio_instance_manager = __esm({
         return {
           currentBootId: await this.getCurrentBootId(),
           observeProcess: (record) => this.observeRecord(this.fromRegistryRecord(record), snapshot),
-          cleanupRecord: (record) => this.cleanupManagedRecord(record),
+          cleanupRecord: (record) => {
+            if (record.processAuthorizationState !== "released" && this.launchControls.has(record.recordId))
+              return;
+            this.cleanupManagedRecord(record);
+          },
           confirmedExitMisses: this.confirmedExitMisses,
           confirmedExitGraceMs: this.confirmedExitGraceMs
         };
       }
       async sweepRegistry(snapshot) {
-        await this.registry.sweep(await this.registrySweepOptions(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);
+          }
+        }
       }
       observeRecord(record, snapshot) {
         if (snapshot.status === "error") {
@@ -4372,9 +5181,16 @@ 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();
@@ -4382,10 +5198,38 @@ var init_studio_instance_manager = __esm({
           this.managedByInstanceId.delete(record.instanceId);
         this.pending.delete(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);
       }
       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;
@@ -4399,6 +5243,12 @@ var init_studio_instance_manager = __esm({
           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);
         await this.persist(record);
@@ -4545,6 +5395,7 @@ var init_studio_instance_manager = __esm({
           ownerPid: record.ownerPid,
           bootId: record.bootId,
           processObservationStatus: record.processObservationStatus,
+          processAuthorizationState: record.processAuthorizationState,
           lastProcessObservationAt: record.lastProcessObservationAt,
           lastSuccessfulProcessObservationAt: record.lastSuccessfulProcessObservationAt,
           lastProcessObservationError: record.lastProcessObservationError,
@@ -4568,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,
@@ -4580,6 +5431,7 @@ var init_studio_instance_manager = __esm({
           bootId: record.bootId,
           deleteLocalPlaceFileOnClose: record.deleteLocalPlaceFileOnClose,
           processObservationStatus: record.processObservationStatus,
+          processAuthorizationState: record.processAuthorizationState ?? "released",
           lastProcessObservationAt: record.lastProcessObservationAt,
           lastSuccessfulProcessObservationAt: record.lastSuccessfulProcessObservationAt,
           lastProcessObservationError: record.lastProcessObservationError,
@@ -7701,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) {
@@ -8630,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)
@@ -9020,6 +9874,9 @@ ${code}`
           managed: true,
           state: record.state,
           pid: record.nativeProcessId ?? record.spawnPid,
+          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,
@@ -9051,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()) {
@@ -9077,9 +9934,21 @@ ${code}`
             body.next_page_token = response.nextPageToken;
           return this._textResult(body);
         }
-        if (action === "status" || action === "close") {
+        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 = await this.instanceManager.getByLaunchId(launch_id);
@@ -9219,7 +10088,11 @@ ${code}`
           });
         }
         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({
@@ -9230,7 +10103,8 @@ ${code}`
           placeVersion,
           connectionTimeoutMs: timeoutMs,
           studioExecutable,
-          processEnvironment
+          processEnvironment,
+          ...requireProcessIdentity ? { requireProcessIdentity: true } : {}
         });
         if (!waitForConnection) {
           return this._textResult({
@@ -10527,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.");
@@ -10565,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",
@@ -10575,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)
                 }
               })
             }]
@@ -10587,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.");
         }
@@ -12253,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",
@@ -12279,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",
@@ -13506,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: {