@chrrxs/robloxstudio-mcp 2.13.0 → 2.14.0

package/studio-plugin/MCPInspectorPlugin.rbxmx

@@ -12,6 +12,11 @@ local Communication = TS.import(script, script, "modules", "Communication")
 local ClientBroker = TS.import(script, script, "modules", "ClientBroker")
 local RuntimeLogBuffer = TS.import(script, script, "modules", "RuntimeLogBuffer")
 local StopPlayMonitor = TS.import(script, script, "modules", "StopPlayMonitor")
+local RenderMonitor = TS.import(script, script, "modules", "RenderMonitor")
+-- Track render-loop liveness so input/screenshot tools can report "window
+-- minimized / not rendering" instead of silently no-op'ing. No-op in the
+-- server DM (RenderStepped can't connect there).
+RenderMonitor.start()
 -- Attach the per-peer LogService.MessageOut listener as early as possible so
 -- boot-time prints from the user's place scripts are captured. Powers the
 -- get_runtime_logs MCP tool. Idempotent; safe to call before UI.init().
@@ -94,8 +99,53 @@ local HttpService = _services.HttpService
 local Players = _services.Players
 local ReplicatedStorage = _services.ReplicatedStorage
 local RunService = _services.RunService
+local ServerStorage = _services.ServerStorage
 local RuntimeLogBuffer = TS.import(script, script.Parent, "RuntimeLogBuffer")
 local MemoryHandlers = TS.import(script, script.Parent, "handlers", "MemoryHandlers")
+local CaptureHandlers = TS.import(script, script.Parent, "handlers", "CaptureHandlers")
+local InputHandlers = TS.import(script, script.Parent, "handlers", "InputHandlers")
+local LuauExec = TS.import(script, script.Parent, "LuauExec")
+local StudioTestService = game:GetService("StudioTestService")
+-- Mirror of Communication.computeInstanceId() — duplicated here because the
+-- client broker runs in the play-server DM where it can't easily import from
+-- the edit-side module, and the place identifier must match what the edit-DM
+-- plugin reports. Both use the same algorithm against the shared DataModel.
+local function computeInstanceId()
+	if game.PlaceId ~= 0 then
+		return `place:{tostring(game.PlaceId)}`
+	end
+	local existing = ServerStorage:GetAttribute("__MCPPlaceId")
+	if type(existing) == "string" and existing ~= "" then
+		return `anon:{existing}`
+	end
+	local fresh = HttpService:GenerateGUID(false)
+	pcall(function()
+		return ServerStorage:SetAttribute("__MCPPlaceId", fresh)
+	end)
+	return `anon:{fresh}`
+end
+local cachedPlaceName
+local function resolvePlaceName()
+	if cachedPlaceName ~= nil then
+		return cachedPlaceName
+	end
+	if game.PlaceId == 0 then
+		cachedPlaceName = game.Name
+		return cachedPlaceName
+	end
+	local MarketplaceService = game:GetService("MarketplaceService")
+	local ok, info = pcall(function()
+		return MarketplaceService:GetProductInfo(game.PlaceId)
+	end)
+	if ok and info ~= nil then
+		local name = info.Name
+		if type(name) == "string" and name ~= "" then
+			cachedPlaceName = name
+			return cachedPlaceName
+		end
+	end
+	return game.Name
+end
 -- The client peer cannot reach the MCP HTTP server - Roblox forbids
 -- HttpService:RequestAsync from the client DM even under PluginSecurity, and
 -- HttpEnabled reads as false there regardless of identity. So the server peer
@@ -109,6 +159,7 @@ local MemoryHandlers = TS.import(script, script.Parent, "handlers", "MemoryHandl
 -- signaling, which works regardless of MCP server state.)
 local MCP_URL = "http://localhost:58741"
 local BROKER_NAME = "__MCPClientBroker"
+local BROKER_OWNER_ATTRIBUTE = "__MCPBrokerOwner"
 -- Endpoints the server-peer broker is allowed to forward to the client peer.
 -- Each requires the client peer's plugin VM (because the buffer / require
 -- cache / etc. lives there) so the server peer alone can't satisfy them.
@@ -116,6 +167,11 @@ local CLIENT_BROKER_ALLOWED_ENDPOINTS = {
 	["/api/execute-luau"] = true,
 	["/api/get-runtime-logs"] = true,
 	["/api/get-memory-breakdown"] = true,
+	["/api/multiplayer-test-state"] = true,
+	["/api/multiplayer-test-leave-client"] = true,
+	["/api/capture-begin"] = true,
+	["/api/simulate-mouse-input"] = true,
+	["/api/simulate-keyboard-input"] = true,
 }
 -- Throttle re-ready calls per proxyId so a brief window of unknownInstance
 -- polls doesn't cause a re-register stampede.
@@ -136,8 +192,13 @@ local function reRegisterProxy(proxyId, role)
 	lastReadyByProxy[_proxyId_1] = now
 	pcall(function()
 		return postJson("/ready", {
-			instanceId = proxyId,
+			pluginSessionId = proxyId,
+			instanceId = computeInstanceId(),
 			role = role,
+			placeId = game.PlaceId,
+			placeName = resolvePlaceName(),
+			dataModelName = game.Name,
+			isRunning = RunService:IsRunning(),
 		})
 	end)
 end
@@ -170,34 +231,11 @@ local function handleExecuteLuau(data)
 			error = "code is required",
 		}
 	end
-	local m = Instance.new("ModuleScript")
-	m.Name = "__MCPClientEval"
-	local okSet, setErr = pcall(function()
-		m.Source = code
-	end)
-	if not okSet then
-		m:Destroy()
-		return {
-			success = false,
-			error = `Source set failed: {tostring(setErr)}`,
-		}
-	end
-	m.Parent = game.Workspace
-	local okReq, result = pcall(function()
-		return require(m)
-	end)
-	m:Destroy()
-	if okReq then
-		return {
-			success = true,
-			returnValue = if result ~= nil then tostring(result) else nil,
-			message = "Code executed successfully",
-		}
-	end
-	return {
-		success = false,
-		error = tostring(result),
-	}
+	-- Shared with edit/server (MetadataHandlers.executeLuau). Adds the IIFE
+	-- wrapper (so `print("hi")` with no return doesn't fail the
+	-- ModuleScript's "must return one value" rule) and JSON-encodes table
+	-- returns instead of yielding "table: 0xaddr".
+	return LuauExec.execute(code)
 end
 local function handleGetRuntimeLogs(data)
 	local d = data or {}
@@ -212,6 +250,77 @@ local function handleGetRuntimeLogs(data)
 		filter = filter,
 	}, "client")
 end
+local function handleMultiplayerTestState()
+	local argsOk, args = pcall(function()
+		return StudioTestService:GetTestArgs()
+	end)
+	local canLeaveOk, canLeave = pcall(function()
+		return StudioTestService:CanLeaveTest()
+	end)
+	local _exp = Players:GetPlayers()
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#_exp)
+	local _callback = function(player)
+		return {
+			name = player.Name,
+			userId = player.UserId,
+			displayName = player.DisplayName,
+		}
+	end
+	for _k, _v in _exp do
+		_newValue[_k] = _callback(_v, _k - 1, _exp)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	local players = _newValue
+	table.sort(players, function(a, b)
+		return a.name < b.name
+	end)
+	return {
+		success = true,
+		peer = "client",
+		isRunning = RunService:IsRunning(),
+		isRunMode = RunService:IsRunMode(),
+		editModeActive = StudioTestService.EditModeActive,
+		testArgsOk = argsOk,
+		testArgs = if argsOk then args else nil,
+		testArgsError = if argsOk then nil else tostring(args),
+		players = players,
+		playerCount = #players,
+		localPlayer = if Players.LocalPlayer then Players.LocalPlayer.Name else nil,
+		canLeaveOk = canLeaveOk,
+		canLeave = if canLeaveOk then canLeave else false,
+		canLeaveError = if canLeaveOk then nil else tostring(canLeave),
+	}
+end
+local function handleMultiplayerTestLeaveClient()
+	local canLeaveOk, canLeave = pcall(function()
+		return StudioTestService:CanLeaveTest()
+	end)
+	if not canLeaveOk then
+		return {
+			error = tostring(canLeave),
+			canLeaveOk = false,
+		}
+	end
+	if not canLeave then
+		return {
+			error = "This client cannot leave the current test session.",
+			canLeaveOk = true,
+			canLeave = false,
+		}
+	end
+	local localPlayer = if Players.LocalPlayer then Players.LocalPlayer.Name else nil
+	task.defer(function()
+		pcall(function()
+			return StudioTestService:LeaveTest()
+		end)
+	end)
+	return {
+		success = true,
+		message = "Client leave requested.",
+		localPlayer = localPlayer,
+	}
+end
 local function setupClientBroker()
 	local rf = ReplicatedStorage:WaitForChild(BROKER_NAME, 10)
 	if not rf or not rf:IsA("RemoteFunction") then
@@ -231,6 +340,21 @@ local function setupClientBroker()
 		if payload and payload.endpoint == "/api/get-memory-breakdown" then
 			return MemoryHandlers.getMemoryBreakdown(payload.data or {})
 		end
+		if payload and payload.endpoint == "/api/multiplayer-test-state" then
+			return handleMultiplayerTestState()
+		end
+		if payload and payload.endpoint == "/api/multiplayer-test-leave-client" then
+			return handleMultiplayerTestLeaveClient()
+		end
+		if payload and payload.endpoint == "/api/capture-begin" then
+			return CaptureHandlers.captureBegin()
+		end
+		if payload and payload.endpoint == "/api/simulate-mouse-input" then
+			return InputHandlers.simulateMouseInput(payload.data or {})
+		end
+		if payload and payload.endpoint == "/api/simulate-keyboard-input" then
+			return InputHandlers.simulateKeyboardInput(payload.data or {})
+		end
 		if payload and payload.endpoint == "/api/execute-luau" then
 			return handleExecuteLuau(payload.data)
 		end
@@ -239,6 +363,7 @@ local function setupClientBroker()
 	end
 end
 local proxyByPlayer = {}
+local serverBrokerStarted = false
 local function pollProxy(proxyId, player, rf)
 	while true do
 		local _condition = player.Parent ~= nil
@@ -251,7 +376,7 @@ local function pollProxy(proxyId, player, rf)
 		end
 		local ok, res = pcall(function()
 			return HttpService:RequestAsync({
-				Url = `{MCP_URL}/poll?instanceId={proxyId}`,
+				Url = `{MCP_URL}/poll?pluginSessionId={proxyId}`,
 				Method = "GET",
 				Headers = {
 					["Content-Type"] = "application/json",
@@ -294,8 +419,12 @@ local function pollProxy(proxyId, player, rf)
 							}
 						end
 					else
+						local allowed = {}
+						for ep in CLIENT_BROKER_ALLOWED_ENDPOINTS do
+							table.insert(allowed, ep)
+						end
 						response = {
-							error = `Client-proxy does not forward {tostring(request.endpoint)}. ` .. `Allowed: /api/execute-luau, /api/get-runtime-logs.`,
+							error = `Client-proxy does not forward {tostring(request.endpoint)}. ` .. `Allowed: {table.concat(allowed, ", ")}.`,
 						}
 					end
 					postJson("/response", {
@@ -315,8 +444,13 @@ local function registerProxy(player, rf)
 	end
 	local proxyId = HttpService:GenerateGUID(false)
 	local ok, res = postJson("/ready", {
-		instanceId = proxyId,
+		pluginSessionId = proxyId,
+		instanceId = computeInstanceId(),
 		role = "client",
+		placeId = game.PlaceId,
+		placeName = resolvePlaceName(),
+		dataModelName = game.Name,
+		isRunning = RunService:IsRunning(),
 	})
 	if not ok or not res or not res.Success then
 		warn(`[MCPFork] proxy register failed for {player.Name}`)
@@ -330,7 +464,7 @@ local function registerProxy(player, rf)
 	local assigned = _condition
 	local _player_1 = player
 	local _arg1 = {
-		instanceId = proxyId,
+		pluginSessionId = proxyId,
 		role = assigned,
 	}
 	proxyByPlayer[_player_1] = _arg1
@@ -341,12 +475,20 @@ end
 -- plugin:SetSetting flag consumed by StopPlayMonitor in the play-server DM,
 -- which doesn't depend on MCP server state or peer registration at all.)
 local function setupServerBroker()
+	if serverBrokerStarted then
+		return nil
+	end
 	local rf = ReplicatedStorage:FindFirstChild(BROKER_NAME)
 	if not rf then
 		rf = Instance.new("RemoteFunction")
 		rf.Name = BROKER_NAME
 		rf.Parent = ReplicatedStorage
 	end
+	if rf:GetAttribute(BROKER_OWNER_ATTRIBUTE) ~= nil then
+		return nil
+	end
+	rf:SetAttribute(BROKER_OWNER_ATTRIBUTE, HttpService:GenerateGUID(false))
+	serverBrokerStarted = true
 	local broker = rf
 	Players.PlayerAdded:Connect(function(p)
 		return registerProxy(p, broker)
@@ -361,14 +503,14 @@ local function setupServerBroker()
 			local _p_1 = p
 			proxyByPlayer[_p_1] = nil
 			postJson("/disconnect", {
-				instanceId = entry.instanceId,
+				pluginSessionId = entry.pluginSessionId,
 			})
 		end
 	end)
 	game:BindToClose(function()
 		for _, entry in proxyByPlayer do
 			postJson("/disconnect", {
-				instanceId = entry.instanceId,
+				pluginSessionId = entry.pluginSessionId,
 			})
 		end
 		table.clear(proxyByPlayer)
@@ -391,9 +533,11 @@ local TS = require(script.Parent.Parent.include.RuntimeLib)
 local _services = TS.import(script, script.Parent.Parent, "node_modules", "@rbxts", "services")
 local HttpService = _services.HttpService
 local RunService = _services.RunService
+local ServerStorage = _services.ServerStorage
 local State = TS.import(script, script.Parent, "State")
 local Utils = TS.import(script, script.Parent, "Utils")
 local UI = TS.import(script, script.Parent, "UI")
+local ensureBridgesInstalled = TS.import(script, script.Parent, "EvalBridges").ensureBridgesInstalled
 local QueryHandlers = TS.import(script, script.Parent, "handlers", "QueryHandlers")
 local PropertyHandlers = TS.import(script, script.Parent, "handlers", "PropertyHandlers")
 local InstanceHandlers = TS.import(script, script.Parent, "handlers", "InstanceHandlers")
@@ -407,8 +551,61 @@ local InputHandlers = TS.import(script, script.Parent, "handlers", "InputHandler
 local LogHandlers = TS.import(script, script.Parent, "handlers", "LogHandlers")
 local SerializationHandlers = TS.import(script, script.Parent, "handlers", "SerializationHandlers")
 local MemoryHandlers = TS.import(script, script.Parent, "handlers", "MemoryHandlers")
-local instanceId = HttpService:GenerateGUID(false)
+-- Per-plugin-load random GUID. Used as the /poll URL param so the server
+-- can tell our polls apart from any other plugin's polls. Not user-facing —
+-- MCP tools and the LLM operate on instanceId (the place identifier).
+local pluginSessionId = HttpService:GenerateGUID(false)
+-- Place-level identifier shared by every plugin running in DataModels of
+-- the same place file (edit DM + playtest server DM + playtest clients).
+-- Format: "place:<PlaceId>" when published, "anon:<UUID>" for unpublished
+-- places where the UUID lives on ServerStorage's __MCPPlaceId attribute
+-- and travels with the .rbxl.
+local MCP_PLACE_ID_ATTRIBUTE = "__MCPPlaceId"
+local function computeInstanceId()
+	if game.PlaceId ~= 0 then
+		return `place:{tostring(game.PlaceId)}`
+	end
+	local existing = ServerStorage:GetAttribute(MCP_PLACE_ID_ATTRIBUTE)
+	if type(existing) == "string" and existing ~= "" then
+		return `anon:{existing}`
+	end
+	local fresh = HttpService:GenerateGUID(false)
+	pcall(function()
+		return ServerStorage:SetAttribute(MCP_PLACE_ID_ATTRIBUTE, fresh)
+	end)
+	return `anon:{fresh}`
+end
+local instanceId = computeInstanceId()
 local assignedRole
+local duplicateInstanceRole = false
+-- Cache the published place name from MarketplaceService:GetProductInfo so
+-- /ready can carry a friendly identifier (e.g. "Natural Disasters") distinct
+-- from game.Name (the DataModel name, often "Place1" in edit). We only fetch
+-- once per plugin load; the published name doesn't change mid-session.
+local cachedPlaceName
+local function resolvePlaceName()
+	if cachedPlaceName ~= nil then
+		return cachedPlaceName
+	end
+	if game.PlaceId == 0 then
+		cachedPlaceName = game.Name
+		return cachedPlaceName
+	end
+	local MarketplaceService = game:GetService("MarketplaceService")
+	local ok, info = pcall(function()
+		return MarketplaceService:GetProductInfo(game.PlaceId)
+	end)
+	if ok and info ~= nil then
+		local name = info.Name
+		if type(name) == "string" and name ~= "" then
+			cachedPlaceName = name
+			return cachedPlaceName
+		end
+	end
+	-- Don't cache failures — could be transient (offline, rate-limited).
+	-- Next /ready will retry. Return game.Name as fallback.
+	return game.Name
+end
 local function detectRole()
 	if not RunService:IsRunning() then
 		return "edit"
@@ -464,6 +661,11 @@ local routeMap = {
 	["/api/start-playtest"] = TestHandlers.startPlaytest,
 	["/api/stop-playtest"] = TestHandlers.stopPlaytest,
 	["/api/get-playtest-output"] = TestHandlers.getPlaytestOutput,
+	["/api/multiplayer-test-start"] = TestHandlers.multiplayerTestStart,
+	["/api/multiplayer-test-state"] = TestHandlers.multiplayerTestState,
+	["/api/multiplayer-test-add-players"] = TestHandlers.multiplayerTestAddPlayers,
+	["/api/multiplayer-test-leave-client"] = TestHandlers.multiplayerTestLeaveClient,
+	["/api/multiplayer-test-end"] = TestHandlers.multiplayerTestEnd,
 	["/api/character-navigation"] = TestHandlers.characterNavigation,
 	["/api/export-build"] = BuildHandlers.exportBuild,
 	["/api/import-build"] = BuildHandlers.importBuild,
@@ -472,6 +674,8 @@ local routeMap = {
 	["/api/insert-asset"] = AssetHandlers.insertAsset,
 	["/api/preview-asset"] = AssetHandlers.previewAsset,
 	["/api/capture-screenshot"] = CaptureHandlers.captureScreenshot,
+	["/api/capture-begin"] = CaptureHandlers.captureBegin,
+	["/api/capture-read"] = CaptureHandlers.captureRead,
 	["/api/simulate-mouse-input"] = InputHandlers.simulateMouseInput,
 	["/api/simulate-keyboard-input"] = InputHandlers.simulateKeyboardInput,
 	["/api/find-and-replace-in-scripts"] = ScriptHandlers.findAndReplaceInScripts,
@@ -524,7 +728,33 @@ end
 -- Without this, every poll during the brief window where the server has just
 -- restarted but hasn't seen our re-ready yet would fire a duplicate /ready.
 local lastReadyPostAt = 0
-local function sendReady(conn)
+-- game.Name is sometimes "Place1" at plugin-load time and only settles to
+-- the real DataModel name (e.g. "Game" once playtest spawns the play DM)
+-- after Studio finishes wiring things up. Re-fire /ready when it changes so
+-- get_connected_instances doesn't show a stale dataModelName forever. Set
+-- up once per plugin load — the connection passed in is whichever was
+-- active when activatePlugin was first called.
+local nameChangeConn
+local sendReady
+local function ensureNameChangeWatcher(conn)
+	if nameChangeConn then
+		return nil
+	end
+	local okSig, signal = pcall(function()
+		return game:GetPropertyChangedSignal("Name")
+	end)
+	if not okSig or not signal then
+		return nil
+	end
+	nameChangeConn = signal:Connect(function()
+		-- sendReady has its own 2s throttle, so rapid burst changes coalesce.
+		sendReady(conn)
+	end)
+end
+function sendReady(conn)
+	if duplicateInstanceRole then
+		return nil
+	end
 	local now = tick()
 	if now - lastReadyPostAt < 2 then
 		return nil
@@ -539,14 +769,36 @@ local function sendReady(conn)
 					["Content-Type"] = "application/json",
 				},
 				Body = HttpService:JSONEncode({
+					pluginSessionId = pluginSessionId,
 					instanceId = instanceId,
 					role = detectRole(),
+					placeId = game.PlaceId,
+					placeName = resolvePlaceName(),
+					dataModelName = game.Name,
+					isRunning = RunService:IsRunning(),
 					pluginReady = true,
 					timestamp = tick(),
 				}),
 			})
 		end)
-		if readyOk and readyResult.Success then
+		if not readyOk then
+			return nil
+		end
+		-- 409 = duplicate_instance_role. Surface in UI and stop polling.
+		if readyResult.StatusCode == 409 then
+			duplicateInstanceRole = true
+			conn.isActive = false
+			local ui = UI.getElements()
+			if State.getActiveTabIndex() == 0 then
+				ui.statusLabel.Text = "Duplicate instance"
+				ui.statusLabel.TextColor3 = Color3.fromRGB(239, 68, 68)
+				ui.detailStatusLabel.Text = "Another Studio is already connected as this place + role"
+				ui.detailStatusLabel.TextColor3 = Color3.fromRGB(239, 68, 68)
+			end
+			warn(`[MCPPlugin] Another Studio is already connected as ({instanceId}, {detectRole()}). Close the other Studio window or this one.`)
+			return nil
+		end
+		if readyResult.Success then
 			local parseOk, readyData = pcall(function()
 				return HttpService:JSONDecode(readyResult.Body)
 			end)
@@ -568,7 +820,7 @@ local function pollForRequests(connIndex)
 	conn.isPolling = true
 	local success, result = pcall(function()
 		return HttpService:RequestAsync({
-			Url = `{conn.serverUrl}/poll?instanceId={instanceId}`,
+			Url = `{conn.serverUrl}/poll?pluginSessionId={pluginSessionId}`,
 			Method = "GET",
 			Headers = {
 				["Content-Type"] = "application/json",
@@ -764,6 +1016,22 @@ local function activatePlugin(connIndex)
 	-- Initial /ready; pollForRequests will also re-fire ready if the server
 	-- later reports knownInstance=false (process restart, etc).
 	sendReady(conn)
+	-- Keep the eval bridges present in the edit DM so that ANY playtest —
+	-- including one the dev starts manually via the Studio Play button —
+	-- clones them into the play DMs and eval_*_runtime works with no setup
+	-- roundtrip. Only the edit DM installs; play DMs already have the cloned
+	-- copies. Idempotent, so reconnects don't re-dirty the place.
+	if not RunService:IsRunning() then
+		task.spawn(function()
+			local result = ensureBridgesInstalled()
+			if not result.installed then
+				warn(`[MCPPlugin] Eval bridge install failed: {result.error}`)
+			end
+		end)
+	end
+	-- Watch for game.Name updates so a stale "Place1" captured at first
+	-- /ready gets refreshed once Studio settles on the real DM name.
+	ensureNameChangeWatcher(conn)
 end
 local function deactivatePlugin(connIndex)
 	local _condition = connIndex
@@ -789,7 +1057,7 @@ local function deactivatePlugin(connIndex)
 				["Content-Type"] = "application/json",
 			},
 			Body = HttpService:JSONEncode({
-				instanceId = instanceId,
+				pluginSessionId = pluginSessionId,
 				timestamp = tick(),
 			}),
 		})
@@ -882,11 +1150,16 @@ local TS = require(script.Parent.Parent.include.RuntimeLib)
 -- ServerScriptService.LoadStringEnabled, so eval_server_runtime works even
 -- when LoadStringEnabled=false (the default in fresh places).
 --
--- Lifecycle: TestHandlers.startPlaytest inserts both scripts into the EDIT
--- DM right before ExecutePlayModeAsync. ExecutePlayModeAsync clones the
--- DataModel into the play DMs, so the scripts come along and run there.
--- TestHandlers cleans them up from the edit DM when ExecutePlayModeAsync
--- returns (test ended for any reason: stop_playtest, manual close, EndTest).
+-- Lifecycle: the bridges live PERMANENTLY in the edit DM. Communication
+-- installs them (ensureBridgesInstalled) when the plugin connects in edit,
+-- and TestHandlers.startPlaytest force-refreshes them right before
+-- ExecutePlayModeAsync. ExecutePlayModeAsync clones the DataModel into the
+-- play DMs, so the scripts come along and run there. We keep them in the edit
+-- DM after a playtest ends (rather than cleaning up) so that a playtest the
+-- dev starts MANUALLY via the Studio Play button — not the MCP start_playtest
+-- tool — also gets the bridges cloned in. This is intentionally a little
+-- intrusive (two helper scripts visible in Explorer) in exchange for a
+-- zero-roundtrip eval_*_runtime experience for devs working 1:1 with an agent.
 --
 -- Archivable handling: ExecutePlayModeAsync's deep-clone SKIPS instances
 -- with Archivable=false (verified empirically in v2.9.0 testing - bridges
@@ -918,9 +1191,9 @@ local BRIDGE_NAMES = {
 -- Embedded Luau. The double `${...}` references our exported names so a
 -- rename here propagates to both the script source and the tool wrappers.
 local SERVER_BRIDGE_SOURCE = `\
--- Auto-installed by @chrrxs/robloxstudio-mcp at start_playtest, removed at\
--- stop_playtest. Provides shared-require-cache eval on the server peer for\
--- the eval_server_runtime MCP tool.\
+-- Installed by @chrrxs/robloxstudio-mcp to power the eval_server_runtime MCP\
+-- tool (shared-require-cache eval on the server during playtests). Inert\
+-- outside Studio (no-ops in live games); safe to leave in place.\
 \
 local ServerScriptService = game:GetService("ServerScriptService")\
 local RunService = game:GetService("RunService")\
@@ -944,9 +1217,9 @@ bf.OnInvoke = function(payload)\
 end\
 `
 local CLIENT_BRIDGE_SOURCE = `\
--- Auto-installed by @chrrxs/robloxstudio-mcp at start_playtest, removed at\
--- stop_playtest. Provides shared-require-cache eval on the client peer for\
--- the eval_client_runtime MCP tool.\
+-- Installed by @chrrxs/robloxstudio-mcp to power the eval_client_runtime MCP\
+-- tool (shared-require-cache eval on the client during playtests). Inert\
+-- outside Studio (no-ops in live games); safe to leave in place.\
 \
 local ReplicatedStorage = game:GetService("ReplicatedStorage")\
 local RunService = game:GetService("RunService")\
@@ -969,6 +1242,25 @@ bf.OnInvoke = function(payload)\
 	return pcall(require, payload)\
 end\
 `
+-- Stamp written onto each installed bridge Script so we can tell whether the
+-- bridge currently in the DM was produced by THIS plugin build. It's a djb2
+-- hash of the actual bridge source plus the plugin version, so ANY change to
+-- the source (or a version bump) yields a new stamp — which makes
+-- ensureBridgesInstalled() force a refresh on the next plugin load instead of
+-- keeping a stale bridge that happens to still be present (e.g. one saved into
+-- the .rbxl from an older build).
+local STAMP_ATTR = "__MCPBridgeStamp"
+local function computeBridgeStamp()
+	local combined = `{SERVER_BRIDGE_SOURCE}|{CLIENT_BRIDGE_SOURCE}`
+	local h = 5381
+	for i = 1, #combined do
+		h = (h * 33 + (string.byte(combined, i))) % 2147483647
+	end
+	-- "2.14.0" is replaced with the package version at package time
+	-- (scripts/build-plugin.mjs injectVersion), so a release bump also restamps.
+	return `{tostring(h)}-2.14.0`
+end
+local BRIDGE_STAMP = computeBridgeStamp()
 local function setSource(scriptInst, source)
 	-- ScriptEditorService is the cleaner API and integrates with Studio's
 	-- edit history; fall back to direct Source mutation (allowed in plugin
@@ -1004,7 +1296,31 @@ local function cleanupBridges()
 		end)
 	end
 end
-local function installBridges()
+-- Idempotent variant: install only if the bridge scripts aren't already
+-- present in the edit DM. Used to keep the bridges always available (so a
+-- playtest the dev starts manually — not via the MCP start_playtest tool —
+-- still clones them into the play DMs). Cheap no-op when already installed,
+-- which avoids re-dirtying the place on every plugin reconnect.
+local installBridges
+local function ensureBridgesInstalled()
+	local _binding = findBridges()
+	local server = _binding.server
+	local client = _binding.client
+	if server and client then
+		-- Both present — but only skip the reinstall if they were produced by
+		-- THIS build. A mismatched/absent stamp means a stale bridge (older
+		-- plugin, or one persisted in the saved place), so force a refresh.
+		local sStamp = server:GetAttribute(STAMP_ATTR)
+		local cStamp = client:GetAttribute(STAMP_ATTR)
+		if sStamp == BRIDGE_STAMP and cStamp == BRIDGE_STAMP then
+			return {
+				installed = true,
+			}
+		end
+	end
+	return installBridges()
+end
+function installBridges()
 	-- Defensive: clear any stale bridges from a prior unclean exit before
 	-- inserting fresh. The injected script also self-cleans its
 	-- ReplicatedStorage/ServerScriptService children at startup, but the
@@ -1017,6 +1333,7 @@ local function installBridges()
 		-- script. cleanupBridges() removes it from the edit DM when the
 		-- playtest ends.
 		setSource(serverScript, SERVER_BRIDGE_SOURCE)
+		serverScript:SetAttribute(STAMP_ATTR, BRIDGE_STAMP)
 		serverScript.Parent = ServerScriptService
 		local sps = getStarterPlayerScripts()
 		if not sps then
@@ -1025,6 +1342,7 @@ local function installBridges()
 		local clientScript = Instance.new("LocalScript")
 		clientScript.Name = CLIENT_SCRIPT_NAME
 		setSource(clientScript, CLIENT_BRIDGE_SOURCE)
+		clientScript:SetAttribute(STAMP_ATTR, BRIDGE_STAMP)
 		clientScript.Parent = sps
 	end)
 	if not ok then
@@ -1039,6 +1357,7 @@ local function installBridges()
 end
 return {
 	cleanupBridges = cleanupBridges,
+	ensureBridgesInstalled = ensureBridgesInstalled,
 	installBridges = installBridges,
 	BRIDGE_NAMES = BRIDGE_NAMES,
 }
@@ -1904,6 +2223,8 @@ return {
           <Properties>
             <string name="Name">CaptureHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
+local TS = require(script.Parent.Parent.Parent.include.RuntimeLib)
+local RenderMonitor = TS.import(script, script.Parent.Parent, "RenderMonitor")
 local CaptureService = game:GetService("CaptureService")
 local AssetService = game:GetService("AssetService")
 local MAX_TILE_SIZE = 1024
@@ -2013,7 +2334,20 @@ local function readPixelsTiled(img, w, h)
 	end
 	return fullBuf
 end
-local function captureScreenshotData()
+-- Triggers CaptureService:CaptureScreenshot and waits for the temporary
+-- content id. Works in any DM, including the play CLIENT (where reading the
+-- pixels back is blocked, but capturing is not). The returned rbxtemp:// id is
+-- a process-scoped handle: it can be dereferenced from a DIFFERENT, more
+-- privileged DM (the edit DM) — see captureRead.
+local function doCaptureScreenshot()
+	-- Fast-fail with a clear reason if the window isn't rendering — otherwise
+	-- CaptureScreenshot's callback never fires and we'd block for the full 10s.
+	local notRendering = RenderMonitor.notRenderingReason()
+	if notRendering ~= nil then
+		return {
+			error = notRendering,
+		}
+	end
 	local contentId
 	CaptureService:CaptureScreenshot(function(id)
 		contentId = id
@@ -2022,11 +2356,21 @@ local function captureScreenshotData()
 	while contentId == nil do
 		if tick() - startTime > 10 then
 			return {
-				error = "Screenshot capture timed out. Ensure the Studio viewport is visible and you are in Edit mode (not Play mode). Known Roblox bug: capture may fail if viewport renders a solid color.",
+				error = "Screenshot capture timed out (CaptureScreenshot callback never fired). The Studio window is likely minimized or occluded — restore it so the viewport renders. (Known Roblox bug: capture can also fail if the viewport renders a solid color.)",
 			}
 		end
 		task.wait(0.1)
 	end
+	return {
+		contentId = contentId,
+	}
+end
+-- Promotes a CaptureScreenshot content id into an EditableImage and reads its
+-- RGBA pixels. MUST run in the edit/plugin context: the running game VM lacks
+-- the privilege to create an EditableImage from a temporary texture id (errors
+-- "cannot currently create editable image from temporary texture id"), while
+-- the edit DM can — even for an id captured in the play client DM.
+local function readContentToBase64(contentId)
 	local editableOk, editableResult = pcall(function()
 		return AssetService:CreateEditableImageAsync(Content.fromUri(contentId))
 	end)
@@ -2056,12 +2400,36 @@ local function captureScreenshotData()
 		data = base64Data,
 	}
 end
+-- Edit-mode single shot: capture and read back in the same (edit) context.
+local function captureScreenshotData()
+	local cap = doCaptureScreenshot()
+	if cap.error ~= nil then
+		return cap
+	end
+	return readContentToBase64(cap.contentId)
+end
 local function captureScreenshot()
 	return captureScreenshotData()
 end
+-- Play-mode step 1 (run on the CLIENT): capture only, return the temp id.
+local function captureBegin()
+	return doCaptureScreenshot()
+end
+-- Play-mode step 2 (run on EDIT): read pixels from a temp id captured elsewhere.
+local function captureRead(requestData)
+	local contentId = requestData.contentId
+	if not (contentId ~= "" and contentId) then
+		return {
+			error = "contentId is required",
+		}
+	end
+	return readContentToBase64(contentId)
+end
 return {
 	captureScreenshotData = captureScreenshotData,
 	captureScreenshot = captureScreenshot,
+	captureBegin = captureBegin,
+	captureRead = captureRead,
 }
 ]]></string>
           </Properties>
@@ -2070,19 +2438,56 @@ return {
           <Properties>
             <string name="Name">InputHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
-local function getVIM()
-	local ok, result = pcall(function()
-		return game:GetService("VirtualInputManager")
+local TS = require(script.Parent.Parent.Parent.include.RuntimeLib)
+-- Virtual input via UserInputService:CreateVirtualInput().
+--
+-- We deliberately do NOT use VirtualInputManager:Send*Event — those methods
+-- are gated behind RobloxScriptSecurity ("lacking capability RobloxScript")
+-- in every context a plugin can reach (edit DM, play server/client DMs), so
+-- they silently never worked. CreateVirtualInput() is callable without that
+-- capability and drives the REAL input pipeline: SendKey feeds
+-- UserInputService.InputBegan/Ended and the control modules (so WASD walks the
+-- character at full WalkSpeed with controls intact, no Humanoid hijack),
+-- SendMouseButton feeds UIS and activates GUI buttons (and hit-tests against
+-- CoreGui), and SendTextInput types into the focused TextBox.
+--
+-- Method set on the VirtualInput object (verified live):
+--   SendKey(isDown: boolean, keyCode: Enum.KeyCode)
+--   SendMouseButton(position: Vector2, inputType: Enum.UserInputType, isDown: boolean)
+--   SendTextInput(text: string)
+-- There is NO SendMouseMove / SendMouseWheel / SendKeyEvent — so "move" and
+-- "scroll" mouse actions are not supported.
+--
+-- Coordinate space: SendMouseButton coordinates are viewport pixels matching
+-- what capture_screenshot returns (window space, origin at the top-left of the
+-- rendered viewport). Pass screenshot pixel coordinates straight through. Note
+-- that UserInputService reports input positions in GUI space, which is offset
+-- from this by GuiService:GetGuiInset() (~58px on the Y axis) — irrelevant for
+-- callers who pick coordinates off a screenshot, which is why we do not
+-- translate here.
+local RenderMonitor = TS.import(script, script.Parent.Parent, "RenderMonitor")
+local UserInputService = game:GetService("UserInputService")
+-- One VirtualInput per plugin VM, reused across calls so that a key held down
+-- in one call (action="press") and released in a later call (action="release")
+-- share the same input source.
+local cachedVI
+local function getVI()
+	if cachedVI then
+		return cachedVI
+	end
+	local ok, vi = pcall(function()
+		return UserInputService:CreateVirtualInput()
 	end)
-	if ok and result then
-		return result
+	if ok and vi ~= nil then
+		cachedVI = vi
+		return cachedVI
 	end
 	return nil
 end
-local BUTTON_MAP = {
-	Left = 0,
-	Right = 1,
-	Middle = 2,
+local MOUSE_TYPE_MAP = {
+	Left = Enum.UserInputType.MouseButton1,
+	Right = Enum.UserInputType.MouseButton2,
+	Middle = Enum.UserInputType.MouseButton3,
 }
 local function simulateMouseInput(requestData)
 	local action = requestData.action
@@ -2093,56 +2498,43 @@ local function simulateMouseInput(requestData)
 		_condition = "Left"
 	end
 	local button = _condition
-	local scrollDirection = requestData.scrollDirection
 	if not (action ~= "" and action) then
 		return {
 			error = "action is required",
 		}
 	end
-	local vim = getVIM()
-	if not vim then
+	if x == nil or y == nil then
 		return {
-			error = "VirtualInputManager is not available in this context",
+			error = "x and y are required",
 		}
 	end
-	local _condition_1 = BUTTON_MAP[button]
-	if _condition_1 == nil then
-		_condition_1 = 0
+	-- Input is silently dropped by the engine when the window isn't rendering
+	-- (e.g. minimized). Surface that instead of returning a false success.
+	local notRendering = RenderMonitor.notRenderingReason()
+	if notRendering ~= nil then
+		return {
+			error = notRendering,
+		}
 	end
-	local buttonNum = _condition_1
+	local vi = getVI()
+	if not vi then
+		return {
+			error = "UserInputService:CreateVirtualInput() is not available in this context",
+		}
+	end
+	local inputType = MOUSE_TYPE_MAP[button] or Enum.UserInputType.MouseButton1
+	local pos = Vector2.new(x, y)
 	local success, err = pcall(function()
 		if action == "click" then
-			if x == nil or y == nil then
-				error("x and y are required for click")
-			end
-			vim:SendMouseButtonEvent(x, y, buttonNum, true)
+			vi:SendMouseButton(pos, inputType, true)
 			task.wait(0.05)
-			vim:SendMouseButtonEvent(x, y, buttonNum, false)
+			vi:SendMouseButton(pos, inputType, false)
 		elseif action == "mouseDown" then
-			if x == nil or y == nil then
-				error("x and y are required for mouseDown")
-			end
-			vim:SendMouseButtonEvent(x, y, buttonNum, true)
+			vi:SendMouseButton(pos, inputType, true)
 		elseif action == "mouseUp" then
-			if x == nil or y == nil then
-				error("x and y are required for mouseUp")
-			end
-			vim:SendMouseButtonEvent(x, y, buttonNum, false)
-		elseif action == "move" then
-			if x == nil or y == nil then
-				error("x and y are required for move")
-			end
-			vim:SendMouseMoveEvent(x, y)
-		elseif action == "scroll" then
-			if x == nil or y == nil then
-				error("x and y are required for scroll")
-			end
-			if not (scrollDirection ~= "" and scrollDirection) then
-				error("scrollDirection is required for scroll")
-			end
-			vim:SendMouseWheelEvent(x, y, scrollDirection == "up")
+			vi:SendMouseButton(pos, inputType, false)
 		else
-			error(`Unknown action: {action}`)
+			error(`Unsupported action "{action}". CreateVirtualInput supports click, mouseDown, mouseUp ` .. `(no move/scroll — those methods don't exist on VirtualInput).`)
 		end
 	end)
 	if success then
@@ -2159,7 +2551,40 @@ local function simulateMouseInput(requestData)
 	}
 end
 local function simulateKeyboardInput(requestData)
+	local notRendering = RenderMonitor.notRenderingReason()
+	if notRendering ~= nil then
+		return {
+			error = notRendering,
+		}
+	end
+	local vi = getVI()
+	if not vi then
+		return {
+			error = "UserInputService:CreateVirtualInput() is not available in this context",
+		}
+	end
+	-- Text mode: type a string into the focused TextBox.
+	local text = requestData.text
+	if text ~= nil then
+		local ok, err = pcall(function()
+			return vi:SendTextInput(text)
+		end)
+		if ok then
+			return {
+				success = true,
+				text = text,
+			}
+		end
+		return {
+			error = `Failed to send text input: {err}`,
+		}
+	end
 	local keyCodeName = requestData.keyCode
+	if not (keyCodeName ~= "" and keyCodeName) then
+		return {
+			error = "keyCode (or text) is required",
+		}
+	end
 	local _condition = (requestData.action)
 	if _condition == nil then
 		_condition = "tap"
@@ -2170,17 +2595,6 @@ local function simulateKeyboardInput(requestData)
 		_condition_1 = 0.1
 	end
 	local duration = _condition_1
-	if not (keyCodeName ~= "" and keyCodeName) then
-		return {
-			error = "keyCode is required",
-		}
-	end
-	local vim = getVIM()
-	if not vim then
-		return {
-			error = "VirtualInputManager is not available in this context",
-		}
-	end
 	local enumOk, keyCode = pcall(function()
 		return (Enum.KeyCode)[keyCodeName]
 	end)
@@ -2191,13 +2605,13 @@ local function simulateKeyboardInput(requestData)
 	end
 	local success, err = pcall(function()
 		if action == "press" then
-			vim:SendKeyEvent(true, keyCode, false)
+			vi:SendKey(true, keyCode)
 		elseif action == "release" then
-			vim:SendKeyEvent(false, keyCode, false)
+			vi:SendKey(false, keyCode)
 		elseif action == "tap" then
-			vim:SendKeyEvent(true, keyCode, false)
+			vi:SendKey(true, keyCode)
 			task.wait(duration)
-			vim:SendKeyEvent(false, keyCode, false)
+			vi:SendKey(false, keyCode)
 		else
 			error(`Unknown action: {action}`)
 		end
@@ -2827,11 +3241,10 @@ return {
             <string name="Name">MetadataHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
 local TS = require(script.Parent.Parent.Parent.include.RuntimeLib)
-local _services = TS.import(script, script.Parent.Parent.Parent, "node_modules", "@rbxts", "services")
-local CollectionService = _services.CollectionService
-local LogService = _services.LogService
+local CollectionService = TS.import(script, script.Parent.Parent.Parent, "node_modules", "@rbxts", "services").CollectionService
 local Utils = TS.import(script, script.Parent.Parent, "Utils")
 local Recording = TS.import(script, script.Parent.Parent, "Recording")
+local LuauExec = TS.import(script, script.Parent.Parent, "LuauExec")
 local ChangeHistoryService = game:GetService("ChangeHistoryService")
 local Selection = game:GetService("Selection")
 local _binding = Utils
@@ -3257,137 +3670,11 @@ local function executeLuau(requestData)
 			error = "Code is required",
 		}
 	end
-	-- Both execution paths (loadstring + ModuleScript-require fallback) run
-	-- the SAME wrapped source so they return a uniform { ok, value, output }
-	-- shape. Two problems the wrapper solves at once:
-	--
-	--   1. pcall(require, m) swallows the real error and returns Roblox's
-	--      generic "Requested module experienced an error while loading"
-	--      message. Wrapping user code in xpcall INSIDE the IIFE keeps the
-	--      ModuleScript itself returning successfully — the real error +
-	--      traceback live in the returned table.
-	--
-	--   2. The ModuleScript path runs in its own environment, so a plugin-
-	--      side getfenv print/warn override never reached user prints. A
-	--      lexical local print/warn inside the IIFE captures user prints
-	--      regardless of which path executes. We also call the real global
-	--      print/warn so messages still flow to Studio's output and
-	--      LogService.MessageOut (which powers get_runtime_logs).
-	--
-	-- Prints from required sub-modules don't reach this capture (they have
-	-- their own env) — those go through the runtime log buffer.
-	local wrapped = `return ((function()\
-\tlocal __mcp_output = \{\}\
-\tlocal __mcp_real_print = print\
-\tlocal __mcp_real_warn = warn\
-\tlocal print = function(...)\
-\t\t__mcp_real_print(...)\
-\t\tlocal args = \{...\}\
-\t\tlocal parts = table.create(#args)\
-\t\tfor i, a in ipairs(args) do parts[i] = tostring(a) end\
-\t\ttable.insert(__mcp_output, table.concat(parts, "\\t"))\
-\tend\
-\tlocal warn = function(...)\
-\t\t__mcp_real_warn(...)\
-\t\tlocal args = \{...\}\
-\t\tlocal parts = table.create(#args)\
-\t\tfor i, a in ipairs(args) do parts[i] = tostring(a) end\
-\t\ttable.insert(__mcp_output, "[warn] " .. table.concat(parts, "\\t"))\
-\tend\
-\tlocal function __mcp_run()\
-{code}\
-\tend\
-\tlocal ok, errOrValue = xpcall(__mcp_run, debug.traceback)\
-\treturn \{ ok = ok, value = errOrValue, output = __mcp_output \}\
-end)())`
-	local runViaModuleScript = function()
-		local m = Instance.new("ModuleScript")
-		m.Name = "__MCPExecLuauPayload"
-		local okSet, setErr = pcall(function()
-			m.Source = wrapped
-		end)
-		if not okSet then
-			m:Destroy()
-			error(`ModuleScript Source set failed: {tostring(setErr)}`)
-		end
-		m.Parent = game:GetService("Workspace")
-		local okReq, reqResult = pcall(function()
-			return require(m)
-		end)
-		m:Destroy()
-		if not okReq then
-			local errMsg = tostring(reqResult)
-			-- pcall(require, m) collapses parse/compile failures into the
-			-- canned engine string below. Walk LogService backward for the
-			-- real diagnostic, which was emitted to MessageOut just before.
-			if errMsg == "Requested module experienced an error while loading" then
-				-- The parser diagnostic is emitted to LogService on the next
-				-- engine frame, not synchronously with pcall(require). task.wait(0)
-				-- yields too early; 50ms is enough to let the frame complete and
-				-- the message land in GetLogHistory.
-				task.wait(0.05)
-				local hist = LogService:GetLogHistory()
-				for i = #hist - 1, 0, -1 do
-					local e = hist[i + 1]
-					if e.messageType == Enum.MessageType.MessageError and string.sub(e.message, 1, 31) == "Workspace.__MCPExecLuauPayload:" then
-						errMsg = e.message
-						break
-					end
-				end
-			end
-			error(errMsg)
-		end
-		return reqResult
-	end
-	local isLoadstringUnavailable = function(err)
-		local errStr = tostring(err)
-		local matchStart = string.find(errStr, "not available", 1, true)
-		return matchStart ~= nil
-	end
-	local success, result = pcall(function()
-		local fn, compileError = loadstring(wrapped)
-		if not fn then
-			if isLoadstringUnavailable(compileError) then
-				return runViaModuleScript()
-			end
-			error(`Compile error: {compileError}`)
-		end
-		return fn()
-	end)
-	-- loadstring throws (not returns nil) in some plugin contexts when
-	-- LoadStringEnabled=false. Catch that as a second-chance fallback.
-	if not success and isLoadstringUnavailable(result) then
-		success, result = pcall(runViaModuleScript)
-	end
-	if not success then
-		-- Outer pcall failed - the wrapper itself didn't even run (e.g. compile
-		-- error in the user code, or ModuleScript setup error). 'result' is the
-		-- raw error string from pcall.
-		return {
-			success = false,
-			error = tostring(result),
-			output = {},
-			message = "Code execution failed",
-		}
-	end
-	-- Wrapper executed - unpack { ok, value, output }.
-	local r = result
-	local capturedOutput = r.output
-	local output = if capturedOutput ~= nil then capturedOutput else ({})
-	if r.ok == true then
-		return {
-			success = true,
-			returnValue = if r.value ~= nil then tostring(r.value) else nil,
-			output = output,
-			message = "Code executed successfully",
-		}
-	end
-	return {
-		success = false,
-		error = if r.value ~= nil then tostring(r.value) else "(unknown error)",
-		output = output,
-		message = "Code execution failed",
-	}
+	-- All wrapping, print/warn capture, loadstring fallback, JSON-encoding
+	-- of table returns, and parse-error recovery live in LuauExec so the
+	-- edit/server (this handler) and the play-client (ClientBroker) take
+	-- the same code path and produce identical output shapes.
+	return LuauExec.execute(code)
 end
 local function undo(_requestData)
 	local success, result = pcall(function()
@@ -5672,10 +5959,11 @@ local TS = require(script.Parent.Parent.Parent.include.RuntimeLib)
 local _services = TS.import(script, script.Parent.Parent.Parent, "node_modules", "@rbxts", "services")
 local HttpService = _services.HttpService
 local LogService = _services.LogService
+local Players = _services.Players
 local RunService = _services.RunService
 local _EvalBridges = TS.import(script, script.Parent.Parent, "EvalBridges")
 local installBridges = _EvalBridges.installBridges
-local cleanupBridges = _EvalBridges.cleanupBridges
+local ensureBridgesInstalled = _EvalBridges.ensureBridgesInstalled
 local StopPlayMonitor = TS.import(script, script.Parent.Parent, "StopPlayMonitor")
 local StudioTestService = game:GetService("StudioTestService")
 local ServerScriptService = game:GetService("ServerScriptService")
@@ -5693,27 +5981,84 @@ local testResult
 local testError
 local stopListenerScript
 local navResultCallback
-local function buildCommandListenerSource()
-	return `local LogService = game:GetService("LogService")\
-local PathfindingService = game:GetService("PathfindingService")\
-local Players = game:GetService("Players")\
-local HttpService = game:GetService("HttpService")\
-local NAV_SIG = "{NAV_SIGNAL}"\
-local NAV_RES = "{NAV_RESULT}"\
-LogService.MessageOut:Connect(function(msg)\
-	if string.sub(msg, 1, #NAV_SIG + 1) == NAV_SIG .. ":" then\
-		local json = string.sub(msg, #NAV_SIG + 2)\
-		task.spawn(function()\
-			local ok, d = pcall(function() return HttpService:JSONDecode(json) end)\
-			if not ok or not d then\
-				print(NAV_RES .. ':\{"success":false,"error":"parse_error"\}')\
-				return\
-			end\
-			local ps = Players:GetPlayers()\
-			if #ps == 0 then\
-				print(NAV_RES .. ':\{"success":false,"error":"no_players"\}')\
-				return\
-			end\
+local multiplayerState = {
+	phase = "idle",
+}
+local function detectPeerRole()
+	if not RunService:IsRunning() then
+		return "edit"
+	end
+	if RunService:IsServer() then
+		return "server"
+	end
+	return "client"
+end
+local function getPlayersSnapshot()
+	local _exp = Players:GetPlayers()
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#_exp)
+	local _callback = function(player)
+		return {
+			name = player.Name,
+			userId = player.UserId,
+			displayName = player.DisplayName,
+		}
+	end
+	for _k, _v in _exp do
+		_newValue[_k] = _callback(_v, _k - 1, _exp)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	local players = _newValue
+	table.sort(players, function(a, b)
+		return a.name < b.name
+	end)
+	return players
+end
+local function cloneMultiplayerState()
+	return {
+		phase = multiplayerState.phase,
+		testId = multiplayerState.testId,
+		numPlayers = multiplayerState.numPlayers,
+		testArgs = multiplayerState.testArgs,
+		startedAt = multiplayerState.startedAt,
+		completedAt = multiplayerState.completedAt,
+		ok = multiplayerState.ok,
+		result = multiplayerState.result,
+		error = multiplayerState.error,
+	}
+end
+local function normalizeNumPlayers(value)
+	local _value = value
+	if not (type(_value) == "number") then
+		return nil
+	end
+	local n = math.floor(value)
+	if n ~= value or n < 1 or n > 8 then
+		return nil
+	end
+	return n
+end
+local function buildCommandListenerSource()
+	return `local LogService = game:GetService("LogService")\
+local PathfindingService = game:GetService("PathfindingService")\
+local Players = game:GetService("Players")\
+local HttpService = game:GetService("HttpService")\
+local NAV_SIG = "{NAV_SIGNAL}"\
+local NAV_RES = "{NAV_RESULT}"\
+LogService.MessageOut:Connect(function(msg)\
+	if string.sub(msg, 1, #NAV_SIG + 1) == NAV_SIG .. ":" then\
+		local json = string.sub(msg, #NAV_SIG + 2)\
+		task.spawn(function()\
+			local ok, d = pcall(function() return HttpService:JSONDecode(json) end)\
+			if not ok or not d then\
+				print(NAV_RES .. ':\{"success":false,"error":"parse_error"\}')\
+				return\
+			end\
+			local ps = Players:GetPlayers()\
+			if #ps == 0 then\
+				print(NAV_RES .. ':\{"success":false,"error":"no_players"\}')\
+				return\
+			end\
 			local char = ps[1].Character or ps[1].CharacterAdded:Wait()\
 			local hum = char:FindFirstChildOfClass("Humanoid")\
 			local root = char:FindFirstChild("HumanoidRootPart")\
@@ -5789,6 +6134,11 @@ local function startPlaytest(requestData)
 			error = 'mode must be "play" or "run"',
 		}
 	end
+	if numPlayers ~= nil then
+		return {
+			error = "start_playtest is single-player only. Use multiplayer_test_start for multi-client StudioTestService sessions.",
+		}
+	end
 	-- Self-heal: if testRunning is stuck true but Studio reports no active
 	-- playtest, the previous start_playtest's task.spawn was orphaned
 	-- (plugin reload mid-test, Studio entered some inconsistent state, etc).
@@ -5800,7 +6150,9 @@ local function startPlaytest(requestData)
 			logConnection = nil
 		end
 		cleanupStopListener()
-		cleanupBridges()
+		-- Note: eval bridges are intentionally NOT cleaned up — they live
+		-- permanently in the edit DM so manual playtests also get them. See
+		-- EvalBridges.ts lifecycle comment.
 	end
 	if testRunning then
 		return {
@@ -5843,17 +6195,14 @@ local function startPlaytest(requestData)
 	if not injected then
 		warn(`[MCP] Failed to inject stop listener: {injErr}`)
 	end
-	-- Auto-install the game-VM eval bridges (ServerEvalBridge + ClientEvalBridge)
-	-- so eval_server_runtime / eval_client_runtime work without manual setup.
-	-- Bridges are cleaned up from the edit DM after the play DMs tear down.
+	-- Force-refresh the game-VM eval bridges (ServerEvalBridge + ClientEvalBridge)
+	-- right before cloning so the play DMs get the current source. They also
+	-- live permanently in the edit DM (installed on connect) so manually-started
+	-- playtests get them too; here we just ensure they're fresh.
 	local bridgeInstall = installBridges()
 	if not bridgeInstall.installed then
 		warn(`[MCP] Eval bridge install failed: {bridgeInstall.error}`)
 	end
-	if numPlayers ~= nil and mode == "run" then
-		local TestService = game:GetService("TestService")
-		TestService.NumberOfPlayers = math.clamp(numPlayers, 1, 8)
-	end
 	task.spawn(function()
 		local ok, result = pcall(function()
 			if mode == "play" then
@@ -5872,12 +6221,13 @@ local function startPlaytest(requestData)
 		end
 		testRunning = false
 		cleanupStopListener()
-		cleanupBridges()
+		-- Eval bridges persist in the edit DM (see EvalBridges.ts) — do not
+		-- clean up here, so the next manual playtest still gets them.
+		ensureBridgesInstalled()
 	end)
-	local msg = if numPlayers ~= nil then `Playtest started in {mode} mode with {numPlayers} player(s).` else `Playtest started in {mode} mode.`
 	local response = {
 		success = true,
-		message = msg,
+		message = `Playtest started in {mode} mode.`,
 	}
 	-- Only mention eval bridges when they failed — when they're fine, the
 	-- detail is noise. eval_server_runtime / eval_client_runtime will surface
@@ -5900,9 +6250,25 @@ local function stopPlaytest(_requestData)
 		}
 	end
 	if not StopPlayMonitor.waitForConsumption() then
-		-- Clean up the pending flag so a future playtest's monitor doesn't fire
-		-- EndTest on its own startup against a stale signal.
+		-- Two distinct failure modes collapse here, distinguished by whether
+		-- THIS edit DM has a playtest tracked:
+		--
+		-- - testRunning=false: no playtest was running from this edit DM
+		--   (true negative). Return "no active playtest" — fine to retry only
+		--   after actually starting a playtest.
+		-- - testRunning=true: a playtest IS running but the cross-DM signal
+		--   didn't propagate within the consumption timeout (false negative
+		--   from the caller's perspective — playtest may actually have ended).
+		--   Tell the caller it's a timing issue and they can retry.
+		--
+		-- Either way clean up the pending flag so a future playtest's monitor
+		-- doesn't fire EndTest on startup against a stale signal.
 		StopPlayMonitor.clearPending()
+		if testRunning then
+			return {
+				error = "Playtest stop signal sent but consumption confirmation timed out. " .. "The playtest may have ended anyway; check get_connected_instances.",
+			}
+		end
 		return {
 			error = "No active playtest to stop.",
 		}
@@ -5944,6 +6310,198 @@ local function getPlaytestOutput(_requestData)
 	_object.testError = testError
 	return _object
 end
+local function multiplayerTestStart(requestData)
+	if RunService:IsRunning() then
+		return {
+			error = "multiplayer_test_start must be called on the edit DataModel. Route with target=edit.",
+		}
+	end
+	local numPlayers = normalizeNumPlayers(requestData.numPlayers)
+	if numPlayers == nil then
+		return {
+			error = "numPlayers must be an integer from 1 to 8",
+		}
+	end
+	if multiplayerState.phase == "starting" or multiplayerState.phase == "running" then
+		return {
+			error = "A multiplayer Studio test is already running",
+			state = cloneMultiplayerState(),
+		}
+	end
+	local testArgs = if requestData.testArgs ~= nil then requestData.testArgs else {}
+	local testId = HttpService:GenerateGUID(false)
+	local bridgeInstall = installBridges()
+	if not bridgeInstall.installed then
+		warn(`[MCP] Eval bridge install failed: {bridgeInstall.error}`)
+	end
+	multiplayerState = {
+		phase = "starting",
+		testId = testId,
+		numPlayers = numPlayers,
+		testArgs = testArgs,
+		startedAt = tick(),
+	}
+	task.spawn(function()
+		multiplayerState.phase = "running"
+		local ok, result = pcall(function()
+			return StudioTestService:ExecuteMultiplayerTestAsync(numPlayers, testArgs)
+		end)
+		multiplayerState.completedAt = tick()
+		multiplayerState.ok = ok
+		if ok then
+			multiplayerState.phase = "completed"
+			multiplayerState.result = result
+			multiplayerState.error = nil
+		else
+			multiplayerState.phase = "failed"
+			multiplayerState.result = nil
+			multiplayerState.error = tostring(result)
+		end
+		ensureBridgesInstalled()
+	end)
+	local response = {
+		success = true,
+		message = `Multiplayer Studio test starting with {numPlayers} player(s).`,
+		testId = testId,
+		phase = multiplayerState.phase,
+		numPlayers = numPlayers,
+		testArgs = testArgs,
+	}
+	if not bridgeInstall.installed then
+		response.evalBridgesError = bridgeInstall.error
+	end
+	return response
+end
+local function multiplayerTestState(_requestData)
+	local peer = detectPeerRole()
+	local response = {
+		success = true,
+		peer = peer,
+		isRunning = RunService:IsRunning(),
+		isRunMode = RunService:IsRunMode(),
+		editModeActive = StudioTestService.EditModeActive,
+	}
+	if peer == "edit" then
+		response.session = cloneMultiplayerState()
+		return response
+	end
+	local argsOk, args = pcall(function()
+		return StudioTestService:GetTestArgs()
+	end)
+	response.testArgsOk = argsOk
+	response.testArgs = if argsOk then args else nil
+	if not argsOk then
+		response.testArgsError = tostring(args)
+	end
+	local players = getPlayersSnapshot()
+	response.players = players
+	response.playerCount = #players
+	if peer == "client" then
+		response.localPlayer = if Players.LocalPlayer then Players.LocalPlayer.Name else nil
+		local canLeaveOk, canLeave = pcall(function()
+			return StudioTestService:CanLeaveTest()
+		end)
+		response.canLeaveOk = canLeaveOk
+		response.canLeave = if canLeaveOk then canLeave else false
+		if not canLeaveOk then
+			response.canLeaveError = tostring(canLeave)
+		end
+	end
+	return response
+end
+local function multiplayerTestAddPlayers(requestData)
+	if not RunService:IsRunning() or not RunService:IsServer() then
+		return {
+			error = "multiplayer_test_add_players must be called on the running server peer. Route with target=server.",
+		}
+	end
+	local numPlayers = normalizeNumPlayers(requestData.numPlayers)
+	if numPlayers == nil then
+		return {
+			error = "numPlayers must be an integer from 1 to 8",
+		}
+	end
+	local before = #Players:GetPlayers()
+	local ok, result = pcall(function()
+		return StudioTestService:AddPlayers(numPlayers)
+	end)
+	if not ok then
+		return {
+			error = tostring(result),
+		}
+	end
+	local _exp = tick()
+	local _condition = (requestData.timeout)
+	if _condition == nil then
+		_condition = 10
+	end
+	local deadline = _exp + _condition
+	while #Players:GetPlayers() < before + numPlayers and tick() < deadline do
+		task.wait(0.1)
+	end
+	local players = getPlayersSnapshot()
+	return {
+		success = true,
+		message = `Requested {numPlayers} additional player(s).`,
+		playerCount = #players,
+		players = players,
+	}
+end
+local function multiplayerTestLeaveClient(_requestData)
+	if not RunService:IsRunning() or RunService:IsServer() then
+		return {
+			error = "multiplayer_test_leave_client must be called on a running client peer. Route with target=client-N.",
+		}
+	end
+	local canLeaveOk, canLeave = pcall(function()
+		return StudioTestService:CanLeaveTest()
+	end)
+	if not canLeaveOk then
+		return {
+			error = tostring(canLeave),
+			canLeaveOk = false,
+		}
+	end
+	if not canLeave then
+		return {
+			error = "This client cannot leave the current test session.",
+			canLeaveOk = true,
+			canLeave = false,
+		}
+	end
+	local localPlayer = if Players.LocalPlayer then Players.LocalPlayer.Name else nil
+	task.defer(function()
+		pcall(function()
+			return StudioTestService:LeaveTest()
+		end)
+	end)
+	return {
+		success = true,
+		message = "Client leave requested.",
+		localPlayer = localPlayer,
+	}
+end
+local function multiplayerTestEnd(requestData)
+	if not RunService:IsRunning() or not RunService:IsServer() then
+		return {
+			error = "multiplayer_test_end must be called on the running server peer. Route with target=server.",
+		}
+	end
+	local value = if requestData.value ~= nil then requestData.value else "ended_by_mcp"
+	local ok, result = pcall(function()
+		return StudioTestService:EndTest(value)
+	end)
+	if not ok then
+		return {
+			error = tostring(result),
+		}
+	end
+	return {
+		success = true,
+		message = "Multiplayer Studio test end requested.",
+		value = value,
+	}
+end
 local function characterNavigation(requestData)
 	if not testRunning then
 		return {
@@ -6015,6 +6573,11 @@ return {
 	startPlaytest = startPlaytest,
 	stopPlaytest = stopPlaytest,
 	getPlaytestOutput = getPlaytestOutput,
+	multiplayerTestStart = multiplayerTestStart,
+	multiplayerTestState = multiplayerTestState,
+	multiplayerTestAddPlayers = multiplayerTestAddPlayers,
+	multiplayerTestLeaveClient = multiplayerTestLeaveClient,
+	multiplayerTestEnd = multiplayerTestEnd,
 	characterNavigation = characterNavigation,
 }
 ]]></string>
@@ -6022,6 +6585,324 @@ return {
         </Item>
       </Item>
       <Item class="ModuleScript" referent="19">
+        <Properties>
+          <string name="Name">LuauExec</string>
+          <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
+-- eslint-disable 
+-- Shared execute_luau machinery for edit/server (MetadataHandlers.executeLuau)
+-- and the play-client peer (ClientBroker.handleExecuteLuau). Three things this
+-- module owns:
+--
+--   1. The IIFE wrapper that captures print/warn, runs user code in xpcall,
+--      and always returns { ok, value, output } so the ModuleScript itself
+--      always returns exactly one value (otherwise `print("hi")` with no
+--      return would fail with "Module code did not return exactly one value").
+--
+--   2. The loadstring-then-ModuleScript-require fallback, with the parse-error
+--      recovery hack that pulls the real diagnostic from LogService.
+--
+--   3. Return-value formatting: tables get HttpService:JSONEncode'd so the
+--      caller sees `{"x":1,"y":2}` instead of `table: 0xaddr`; primitives
+--      pass through tostring. The encode is pcall'd so cycles or
+--      non-serializable values gracefully fall back to tostring.
+--
+-- Before this module existed, the client peer used a stripped-down
+-- require-only execution path that lacked both the wrapper and the JSON
+-- formatting, producing two well-known papercuts:
+--   - `print("hi")` (no return) failed with "Module code did not return..."
+--   - Returning a table yielded `table: 0xaddr` instead of structured data.
+local HttpService = game:GetService("HttpService")
+local LogService = game:GetService("LogService")
+local PAYLOAD_INSTANCE_NAME = "__MCPExecLuauPayload"
+local PAYLOAD_PATH_PREFIX = `Workspace.{PAYLOAD_INSTANCE_NAME}:`
+-- Number of lines the wrapper emits BEFORE the first line of user code.
+-- Used both inside the wrapper (Luau __mcp_LINE_OFFSET) and on the TS side
+-- (remapPayloadLines, for compile errors recovered from LogService) so user
+-- code errors report user-relative line numbers instead of the inflated
+-- "line 23" the wrapper would otherwise expose. If you reorder buildWrapper's
+-- prefix lines, update this constant — there's a self-check below.
+local WRAPPER_LINE_OFFSET = 23
+-- Count source lines so the wrapper can filter traceback frames that fall
+-- outside the user code range (the wrapper's own preamble/postamble lines).
+local function countLines(s)
+	local n = 1
+	local size = #s
+	do
+		local i = 1
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				i += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (i <= size) then
+				break
+			end
+			if string.sub(s, i, i) == "\n" then
+				n += 1
+			end
+		end
+	end
+	return n
+end
+local function buildWrapper(code)
+	-- If you reorder the prefix lines below, update WRAPPER_LINE_OFFSET to
+	-- match the number of lines emitted BEFORE the ${code} substitution.
+	-- The constant is mirrored inside the wrapper (__mcp_LINE_OFFSET) and
+	-- used by remapPayloadLines on the TS side.
+	local userLines = countLines(code)
+	return `return ((function()\
+\tlocal __mcp_traceback\
+\tlocal __mcp_remap\
+\tlocal __mcp_LINE_OFFSET = {WRAPPER_LINE_OFFSET}\
+\tlocal __mcp_USER_LINES = {userLines}\
+\tlocal __mcp_output = \{\}\
+\tlocal __mcp_real_print = print\
+\tlocal __mcp_real_warn = warn\
+\tlocal print = function(...)\
+\t\t__mcp_real_print(...)\
+\t\tlocal args = \{...\}\
+\t\tlocal parts = table.create(#args)\
+\t\tfor i, a in ipairs(args) do parts[i] = tostring(a) end\
+\t\ttable.insert(__mcp_output, table.concat(parts, "\\t"))\
+\tend\
+\tlocal warn = function(...)\
+\t\t__mcp_real_warn(...)\
+\t\tlocal args = \{...\}\
+\t\tlocal parts = table.create(#args)\
+\t\tfor i, a in ipairs(args) do parts[i] = tostring(a) end\
+\t\ttable.insert(__mcp_output, "[warn] " .. table.concat(parts, "\\t"))\
+\tend\
+\tlocal function __mcp_run()\
+{code}\
+\tend\
+\t__mcp_remap = function(s)\
+\t\t-- Two chunk-name formats can reference our payload:\
+\t\t--   * "Workspace.__MCPExecLuauPayload:N" — ModuleScript:require fallback path\
+\t\t--   * "[string \\"return ((function()...\\"]:N" — loadstring() (default in plugin)\
+\t\t-- Subtract LINE_OFFSET to get the user-relative number, then clamp.\
+\t\t-- Clamping matters for unclosed constructs ("local x = (") where the\
+\t\t-- parser keeps reading into wrapper postamble and reports a payload\
+\t\t-- line past user EOF. Without clamping the message says "user_code:49"\
+\t\t-- for one-line input, framing the wrapper as user code.\
+\t\tlocal function __mcp_user_line(payload_n)\
+\t\t\tlocal user_n = payload_n - __mcp_LINE_OFFSET\
+\t\t\tif user_n < 1 then return "1" end\
+\t\t\tif user_n > __mcp_USER_LINES then return tostring(__mcp_USER_LINES) .. " (at end of input)" end\
+\t\t\treturn tostring(user_n)\
+\t\tend\
+\t\ts = string.gsub(s, "__MCPExecLuauPayload:(%d+)", function(num)\
+\t\t\tlocal n = tonumber(num)\
+\t\t\tif n then return "user_code:" .. __mcp_user_line(n) end\
+\t\t\treturn "user_code:" .. num\
+\t\tend)\
+\t\ts = string.gsub(s, '%[string "[^"]+"%]:(%d+)', function(num)\
+\t\t\tlocal n = tonumber(num)\
+\t\t\tif n then return "user_code:" .. __mcp_user_line(n) end\
+\t\t\treturn "user_code:" .. num\
+\t\tend)\
+\t\treturn s\
+\tend\
+\t__mcp_traceback = function(err)\
+\t\tlocal raw = debug.traceback(tostring(err), 2)\
+\t\tlocal kept = \{\}\
+\t\tfor line in string.gmatch(raw, "[^\\n]+") do\
+\t\t\t-- Extract referenced line number (either chunk-name format).\
+\t\t\tlocal num_str = string.match(line, "__MCPExecLuauPayload:(%d+)")\
+\t\t\t\tor string.match(line, '%[string "[^"]+"%]:(%d+)')\
+\t\t\tlocal n = num_str and tonumber(num_str)\
+\t\t\t-- Strip the "in function '__mcp_run'" annotation before doing\
+\t\t\t-- any filtering, because user-code frames carry that suffix —\
+\t\t\t-- the entire user payload is hosted inside __mcp_run, so EVERY\
+\t\t\t-- user frame would otherwise match a naive "__mcp_" filter and\
+\t\t\t-- get dropped. Strip first, then apply filters.\
+\t\t\tline = (string.gsub(line, " in function '__mcp_run'", ""))\
+\t\t\tlocal skip = string.find(line, "MCPPlugin", 1, true)\
+\t\t\t\tor string.find(line, "__mcp_", 1, true)\
+\t\t\t\tor string.find(line, "in function 'xpcall'", 1, true)\
+\t\t\t-- Frame lines pointing at wrapper preamble/postamble (outside\
+\t\t\t-- user range) are wrapper internals — drop them. Lines without\
+\t\t\t-- a payload-chunk line number (the traceback header / engine\
+\t\t\t-- C frames) are kept; remap is a no-op for them.\
+\t\t\tif n and (n <= __mcp_LINE_OFFSET or n > __mcp_LINE_OFFSET + __mcp_USER_LINES) then\
+\t\t\t\tskip = true\
+\t\t\tend\
+\t\t\tif not skip then\
+\t\t\t\ttable.insert(kept, __mcp_remap(line))\
+\t\t\tend\
+\t\tend\
+\t\treturn table.concat(kept, "\\n")\
+\tend\
+\tlocal ok, errOrValue = xpcall(__mcp_run, __mcp_traceback)\
+\treturn \{ ok = ok, value = errOrValue, output = __mcp_output \}\
+end)())`
+end
+-- TS-side mirror of the Lua __mcp_remap. Used by runViaModuleScript when
+-- pulling the real compile-error diagnostic out of LogService — that error
+-- references the payload module's line number directly, and never passes
+-- through the IIFE's runtime wrapper.
+local function remapPayloadLines(s, userLines)
+	-- Mirror of the Lua __mcp_remap inside the wrapper, for paths that
+	-- don't pass through the IIFE (compile errors recovered from
+	-- LogService, the immediate loadstring compileError surface). Same
+	-- two-format coverage plus the same clamp: unclosed user constructs
+	-- let the parser consume wrapper postamble, so the raw payload line
+	-- is sometimes well past user EOF — clamp to [1, userLines] and
+	-- annotate so the error doesn't say "user_code:49" for one-line input.
+	local userLine = function(payload)
+		local u = payload - WRAPPER_LINE_OFFSET
+		if u < 1 then
+			return "1"
+		end
+		if u > userLines then
+			return `{tostring(userLines)} (at end of input)`
+		end
+		return tostring(u)
+	end
+	local out = s
+	local a = string.gsub(out, "__MCPExecLuauPayload:(%d+)", function(num)
+		local n = tonumber(num)
+		if n ~= nil then
+			return `user_code:{userLine(n)}`
+		end
+		return `user_code:{num}`
+	end)
+	out = a
+	local b = string.gsub(out, '%[string "[^"]+"%]:(%d+)', function(num)
+		local n = tonumber(num)
+		if n ~= nil then
+			return `user_code:{userLine(n)}`
+		end
+		return `user_code:{num}`
+	end)
+	out = b
+	return out
+end
+local function runViaModuleScript(wrapped, userLines)
+	local m = Instance.new("ModuleScript")
+	m.Name = PAYLOAD_INSTANCE_NAME
+	local okSet, setErr = pcall(function()
+		m.Source = wrapped
+	end)
+	if not okSet then
+		m:Destroy()
+		-- error(..., 0) suppresses the "user_MCPPlugin.rbxmx.MCPPlugin.modules.LuauExec:N:"
+		-- prefix that error() would otherwise prepend, keeping the visible
+		-- message focused on the user-actionable error rather than our path.
+		error(`ModuleScript Source set failed: {tostring(setErr)}`, 0)
+	end
+	m.Parent = game:GetService("Workspace")
+	local okReq, reqResult = pcall(function()
+		return require(m)
+	end)
+	m:Destroy()
+	if not okReq then
+		local errMsg = tostring(reqResult)
+		-- pcall(require, m) collapses parse/compile failures into the canned
+		-- engine string. The real diagnostic was emitted to LogService on the
+		-- next engine frame — give it ~50ms to land then scan backward.
+		if errMsg == "Requested module experienced an error while loading" then
+			task.wait(0.05)
+			local hist = LogService:GetLogHistory()
+			for i = #hist - 1, 0, -1 do
+				local e = hist[i + 1]
+				if e.messageType == Enum.MessageType.MessageError and string.sub(e.message, 1, #PAYLOAD_PATH_PREFIX) == PAYLOAD_PATH_PREFIX then
+					errMsg = e.message
+					break
+				end
+			end
+		end
+		-- Compile errors reference the payload module's line number directly
+		-- — remap + clamp to user-relative line numbers so `local x = 1 +`
+		-- reports :1: instead of :23:, and reports the clamp annotation
+		-- when the parser ran off the end of user code into wrapper code.
+		error(remapPayloadLines(errMsg, userLines), 0)
+	end
+	return reqResult
+end
+local function isLoadstringUnavailable(err)
+	local errStr = tostring(err)
+	local matchStart = string.find(errStr, "not available", 1, true)
+	return matchStart ~= nil
+end
+-- Returns a string suitable for `returnValue`. Tables get JSON-encoded so
+-- the caller sees structured data instead of "table: 0xaddr". Anything that
+-- JSONEncode chokes on (cycles, Roblox userdata) falls back to tostring.
+local function formatReturnValue(value)
+	if value == nil then
+		return ""
+	end
+	local _value = value
+	if type(_value) == "table" then
+		local ok, encoded = pcall(function()
+			return HttpService:JSONEncode(value)
+		end)
+		if ok then
+			return encoded
+		end
+	end
+	return tostring(value)
+end
+local function execute(code)
+	if not (code ~= "" and code) or code == "" then
+		return {
+			success = false,
+			error = "code is required",
+		}
+	end
+	local wrapped = buildWrapper(code)
+	local userLines = countLines(code)
+	local success, result = pcall(function()
+		local fn, compileError = loadstring(wrapped)
+		if not fn then
+			if isLoadstringUnavailable(compileError) then
+				return runViaModuleScript(wrapped, userLines)
+			end
+			error(`Compile error: {remapPayloadLines(tostring(compileError), userLines)}`, 0)
+		end
+		return fn()
+	end)
+	-- loadstring can throw (not return nil) when ServerScriptService.
+	-- LoadStringEnabled is false; treat that as a second-chance fallback.
+	if not success and isLoadstringUnavailable(result) then
+		success, result = pcall(function()
+			return runViaModuleScript(wrapped, userLines)
+		end)
+	end
+	if not success then
+		return {
+			success = false,
+			error = tostring(result),
+			output = {},
+			message = "Code execution failed",
+		}
+	end
+	local r = result
+	local capturedOutput = r.output
+	local output = if capturedOutput ~= nil then capturedOutput else ({})
+	if r.ok == true then
+		return {
+			success = true,
+			returnValue = if r.value ~= nil then formatReturnValue(r.value) else nil,
+			output = output,
+			message = "Code executed successfully",
+		}
+	end
+	return {
+		success = false,
+		error = if r.value ~= nil then tostring(r.value) else "(unknown error)",
+		output = output,
+		message = "Code execution failed",
+	}
+end
+return {
+	execute = execute,
+}
+]]></string>
+        </Properties>
+      </Item>
+      <Item class="ModuleScript" referent="20">
         <Properties>
           <string name="Name">Recording</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -6051,7 +6932,75 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="20">
+      <Item class="ModuleScript" referent="21">
+        <Properties>
+          <string name="Name">RenderMonitor</string>
+          <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
+local TS = require(script.Parent.Parent.include.RuntimeLib)
+-- Detects whether the Studio window is actually rendering, so virtual input
+-- and screenshot tools can surface a clear reason instead of silently failing.
+--
+-- When a Studio window is MINIMIZED, the engine suspends the render loop AND
+-- input processing, but keeps running scripts (Heartbeat keeps firing). That's
+-- why simulate_*_input would return success while having zero effect, and
+-- CaptureService:CaptureScreenshot would time out. Validated live: during a 3s
+-- minimize, RenderStepped's max inter-frame gap was 5.08s while Heartbeat's was
+-- 0.10s. So RenderStepped freshness is the reliable "is this window rendering?"
+-- signal; Heartbeat is not.
+local RunService = TS.import(script, script.Parent.Parent, "node_modules", "@rbxts", "services").RunService
+local lastFrame = 0
+local connected = false
+-- Above this many seconds since the last rendered frame, we treat the window
+-- as not rendering. RenderStepped normally fires every ~16ms; a multi-second
+-- gap only happens when minimized/suspended, so 1s cleanly avoids false
+-- positives from ordinary frame hitches while still catching the real case.
+local STALE_THRESHOLD = 1.0
+local function start()
+	if connected then
+		return nil
+	end
+	-- RenderStepped can only be connected from a client/edit render loop; it
+	-- throws in the play-server DM. pcall so a server-DM call is a safe no-op
+	-- (connected stays false → notRenderingReason() returns undefined there).
+	local ok = pcall(function()
+		RunService.RenderStepped:Connect(function()
+			lastFrame = tick()
+		end)
+	end)
+	if ok then
+		connected = true
+		lastFrame = tick()
+	end
+end
+local function secondsSinceFrame()
+	if not connected then
+		return 0
+	end
+	return tick() - lastFrame
+end
+-- Returns a human-readable reason if the window appears minimized / not
+-- rendering (so input + screenshots won't work), else undefined. Fail-open:
+-- when the monitor isn't active in this DM (server peer, or connect failed) it
+-- returns undefined so we never block on a false signal.
+local function notRenderingReason()
+	if not connected then
+		return nil
+	end
+	local gap = secondsSinceFrame()
+	if gap > STALE_THRESHOLD then
+		return string.format("Studio window appears minimized or not rendering (no frame in %.1fs). " .. "Virtual input and screenshots only work while the window is visible — " .. "restore/un-minimize the Studio window and retry.", gap)
+	end
+	return nil
+end
+return {
+	start = start,
+	secondsSinceFrame = secondsSinceFrame,
+	notRenderingReason = notRenderingReason,
+}
+]]></string>
+        </Properties>
+      </Item>
+      <Item class="ModuleScript" referent="22">
         <Properties>
           <string name="Name">RuntimeLogBuffer</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -6232,11 +7181,11 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="21">
+      <Item class="ModuleScript" referent="23">
         <Properties>
           <string name="Name">State</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
-local CURRENT_VERSION = "2.11.4"
+local CURRENT_VERSION = "2.14.0"
 local MAX_CONNECTIONS = 5
 local BASE_PORT = 58741
 local activeTabIndex = 0
@@ -6328,61 +7277,96 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="22">
+      <Item class="ModuleScript" referent="24">
         <Properties>
           <string name="Name">StopPlayMonitor</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
--- Cross-DM stop_playtest signaling via plugin:SetSetting.
+local TS = require(script.Parent.Parent.include.RuntimeLib)
+-- Cross-DM stop_playtest signaling via plugin:SetSetting, scoped by
+-- per-instance setting key so the same Studio process can host playtests
+-- for multiple places without one place's stop_playtest yanking another's.
 --
 -- `plugin:SetSetting` / `plugin:GetSetting` is a per-plugin persistent store
--- that's shared across every DataModel the plugin runs in (edit, play-server,
--- play-clients). We use it as a one-bit flag for "please call EndTest in the
--- play-server DM":
---
---   * The edit DM's stopPlaytest handler writes the flag (requestStop).
---   * A monitor loop running inside the play-server DM polls the flag at 1Hz
---     and calls StudioTestService:EndTest when it flips true, then resets it.
---   * The edit DM then waits up to ~2.5s for the flag to be reset, which
---     tells us a play-server actually consumed the request (no false-positive
---     success when nothing was running).
+-- shared across every DataModel the plugin runs in (edit DMs, play-server
+-- DMs, play-client DMs). For each connected place we use a dedicated key
+-- "MCP_STOP_PLAY_<instanceId>" as a single-bit mailbox:
 --
--- Why this is simpler than the previous edit-proxy registration:
---   * Doesn't depend on the MCP server tracking peer roles at all.
---   * Survives MCP server restarts: monitor loop is local to the play-server
---     plugin lifetime, not to any HTTP/registration state.
---   * No need for cross-DM LogService.MessageOut reflection (which we verified
---     does not work edit -> play-server anyway).
+--   * The edit DM's stopPlaytest handler writes `true` into its own key
+--     (computed from its placeId / ServerStorage anon UUID).
+--   * Each play-server DM's monitor loop polls the key matching its own
+--     instanceId at 0.1Hz; on `true` it clears the key and calls
+--     StudioTestService:EndTest. Play-server DMs for other places never
+--     touch this key.
+--   * The edit DM waits up to ~8s for its key to be cleared, confirming a
+--     matching play-server actually consumed the request.
 --
--- Pattern mirrors the official Roblox Studio MCP
--- (Roblox/studio-rust-mcp-server, plugin/src/Utils/GameStopUtil.luau).
+-- Earlier versions used a single shared boolean flag, which let any
+-- play-server DM in the same Studio process consume any place's stop
+-- request — silently yanking teammates' playtests. The per-key scoping
+-- below is the fix.
+local _services = TS.import(script, script.Parent.Parent, "node_modules", "@rbxts", "services")
+local HttpService = _services.HttpService
+local ServerStorage = _services.ServerStorage
 local StudioTestService = game:GetService("StudioTestService")
-local SETTING_KEY = "MCP_STOP_PLAY_SIGNAL"
-local POLL_INTERVAL_SEC = 1
-local WAIT_FOR_CONSUMPTION_TIMEOUT_SEC = 2.5
+local SETTING_KEY_PREFIX = "MCP_STOP_PLAY_"
+-- Monitor checks the key at this cadence. 0.1s keeps worst-case detection
+-- lag tight so the consumption-confirmation window doesn't have to absorb
+-- polling jitter on top of EndTest's teardown time.
+local POLL_INTERVAL_SEC = 0.1
+-- Total time we wait for the matching play-server DM to consume the
+-- signal. Must cover: monitor detection (<= POLL_INTERVAL_SEC) +
+-- StudioTestService:EndTest teardown (several seconds on heavier places).
+-- 8s is comfortable; the tighter poll above keeps real cases well under.
+local WAIT_FOR_CONSUMPTION_TIMEOUT_SEC = 8.0
 local WAIT_POLL_SEC = 0.1
 local pluginRef
 local function init(p)
 	pluginRef = p
 end
+-- Mirror of Communication.computeInstanceId(). Duplicated here because
+-- StopPlayMonitor runs in both edit and play-server DMs, and both must
+-- agree on the place identifier (published places: placeId; unpublished:
+-- UUID on ServerStorage's __MCPPlaceId attribute, travels with the .rbxl
+-- into the play DM).
+local function computeInstanceId()
+	if game.PlaceId ~= 0 then
+		return `place:{tostring(game.PlaceId)}`
+	end
+	local existing = ServerStorage:GetAttribute("__MCPPlaceId")
+	if type(existing) == "string" and existing ~= "" then
+		return `anon:{existing}`
+	end
+	local fresh = HttpService:GenerateGUID(false)
+	pcall(function()
+		return ServerStorage:SetAttribute("__MCPPlaceId", fresh)
+	end)
+	return `anon:{fresh}`
+end
+local function settingKey(instanceId)
+	return SETTING_KEY_PREFIX .. instanceId
+end
 local function startMonitor()
 	if not pluginRef then
 		warn("[MCP] StopPlayMonitor.startMonitor called before init; skipping")
 		return nil
 	end
-	-- Clear any stale value left from a prior session. If a real stop request
-	-- is in-flight when this runs, the requesting edit DM will set it again
-	-- within its 2.5s wait window.
+	local myKey = settingKey(computeInstanceId())
+	-- Clear any stale value left from a prior session. If a real stop
+	-- request is in-flight when this runs, the requesting edit DM will
+	-- write again within its consumption-confirmation window.
 	pcall(function()
-		return pluginRef:SetSetting(SETTING_KEY, false)
+		return pluginRef:SetSetting(myKey, false)
 	end)
 	task.spawn(function()
 		while true do
 			local okGet, val = pcall(function()
-				return pluginRef:GetSetting(SETTING_KEY)
+				return pluginRef:GetSetting(myKey)
 			end)
 			if okGet and val == true then
+				-- Consume the flag first so requestStop's
+				-- waitForConsumption returns success, then end the test.
 				pcall(function()
-					return pluginRef:SetSetting(SETTING_KEY, false)
+					return pluginRef:SetSetting(myKey, false)
 				end)
 				pcall(function()
 					return StudioTestService:EndTest("stopped_by_mcp")
@@ -6396,8 +7380,9 @@ local function requestStop()
 	if not pluginRef then
 		return false
 	end
+	local myKey = settingKey(computeInstanceId())
 	local ok = pcall(function()
-		return pluginRef:SetSetting(SETTING_KEY, true)
+		return pluginRef:SetSetting(myKey, true)
 	end)
 	return ok
 end
@@ -6405,10 +7390,11 @@ local function waitForConsumption()
 	if not pluginRef then
 		return false
 	end
+	local myKey = settingKey(computeInstanceId())
 	local start = tick()
 	while tick() - start < WAIT_FOR_CONSUMPTION_TIMEOUT_SEC do
 		local okGet, val = pcall(function()
-			return pluginRef:GetSetting(SETTING_KEY)
+			return pluginRef:GetSetting(myKey)
 		end)
 		if okGet and val ~= true then
 			return true
@@ -6421,8 +7407,9 @@ local function clearPending()
 	if not pluginRef then
 		return nil
 	end
+	local myKey = settingKey(computeInstanceId())
 	pcall(function()
-		return pluginRef:SetSetting(SETTING_KEY, false)
+		return pluginRef:SetSetting(myKey, false)
 	end)
 end
 return {
@@ -6435,7 +7422,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="23">
+      <Item class="ModuleScript" referent="25">
         <Properties>
           <string name="Name">UI</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -7186,7 +8173,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="24">
+      <Item class="ModuleScript" referent="26">
         <Properties>
           <string name="Name">Utils</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -7716,11 +8703,11 @@ return {
         </Properties>
       </Item>
     </Item>
-    <Item class="Folder" referent="28">
+    <Item class="Folder" referent="30">
       <Properties>
         <string name="Name">include</string>
       </Properties>
-      <Item class="ModuleScript" referent="25">
+      <Item class="ModuleScript" referent="27">
         <Properties>
           <string name="Name">Promise</string>
           <string name="Source"><![CDATA[--[[
@@ -9794,7 +10781,7 @@ return Promise
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="26">
+      <Item class="ModuleScript" referent="28">
         <Properties>
           <string name="Name">RuntimeLib</string>
           <string name="Source"><![CDATA[local Promise = require(script.Parent.Promise)
@@ -10061,15 +11048,15 @@ return TS
         </Properties>
       </Item>
     </Item>
-    <Item class="Folder" referent="29">
+    <Item class="Folder" referent="31">
       <Properties>
         <string name="Name">node_modules</string>
       </Properties>
-      <Item class="Folder" referent="30">
+      <Item class="Folder" referent="32">
         <Properties>
           <string name="Name">@rbxts</string>
         </Properties>
-      <Item class="ModuleScript" referent="27">
+      <Item class="ModuleScript" referent="29">
         <Properties>
           <string name="Name">services</string>
           <string name="Source"><![CDATA[return setmetatable({}, {