@chrrxs/robloxstudio-mcp 2.15.1 → 2.16.0

package/studio-plugin/src/modules/ClientBroker.ts

@@ -4,6 +4,7 @@ import MemoryHandlers from "./handlers/MemoryHandlers";
 import SceneAnalysisHandlers from "./handlers/SceneAnalysisHandlers";
 import CaptureHandlers from "./handlers/CaptureHandlers";
 import InputHandlers from "./handlers/InputHandlers";
+import EvalRuntimeHandlers from "./handlers/EvalRuntimeHandlers";
 import LuauExec from "./LuauExec";
 import State from "./State";
 
@@ -87,6 +88,7 @@ interface BrokerEnvelope {
 // cache / etc. lives there) so the server peer alone can't satisfy them.
 const CLIENT_BROKER_ALLOWED_ENDPOINTS = new Set<string>([
 	"/api/execute-luau",
+	"/api/eval-runtime",
 	"/api/get-runtime-logs",
 	"/api/get-memory-breakdown",
 	"/api/get-scene-analysis",
@@ -175,8 +177,8 @@ function handleGetRuntimeLogs(data: Record<string, unknown> | undefined): unknow
 	const since = d.since as number | undefined;
 	const tail = d.tail as number | undefined;
 	const filter = d.filter as string | undefined;
-	// "client" is the generic peer tag; MCP-side aggregator overrides with
-	// the specific role (e.g. "client-1") on target=all fan-out.
+	// "client" is the generic capture tag; MCP-side aggregation overrides it
+	// with the specific role (e.g. "client-1") for capturedBy.
 	return RuntimeLogBuffer.query({ since, tail, filter }, "client");
 }
 
@@ -266,6 +268,9 @@ function setupClientBroker() {
 		if (payload && payload.endpoint === "/api/execute-luau") {
 			return handleExecuteLuau(payload.data);
 		}
+		if (payload && payload.endpoint === "/api/eval-runtime") {
+			return EvalRuntimeHandlers.evalRuntime(payload.data ?? {});
+		}
 		// Legacy: raw execute-luau payload at the top level.
 		return handleExecuteLuau(payload as Record<string, unknown> | undefined);
 	};

package/studio-plugin/src/modules/Communication.ts

@@ -2,7 +2,7 @@ import { HttpService, RunService, ServerStorage } from "@rbxts/services";
 import State from "./State";
 import Utils from "./Utils";
 import UI from "./UI";
-import { ensureBridgesInstalled } from "./EvalBridges";
+import { cleanupLegacyEditBridges } from "./EvalBridges";
 import QueryHandlers from "./handlers/QueryHandlers";
 import PropertyHandlers from "./handlers/PropertyHandlers";
 import InstanceHandlers from "./handlers/InstanceHandlers";
@@ -17,6 +17,7 @@ import LogHandlers from "./handlers/LogHandlers";
 import SerializationHandlers from "./handlers/SerializationHandlers";
 import MemoryHandlers from "./handlers/MemoryHandlers";
 import SceneAnalysisHandlers from "./handlers/SceneAnalysisHandlers";
+import EvalRuntimeHandlers from "./handlers/EvalRuntimeHandlers";
 import { Connection, RequestPayload, PollResponse, ReadyResponse } from "../types";
 
 // Per-plugin-load random GUID. Used as the /poll URL param so the server
@@ -129,6 +130,7 @@ const routeMap: Record<string, Handler> = {
 	"/api/get-tagged": MetadataHandlers.getTagged,
 	"/api/get-selection": MetadataHandlers.getSelection,
 	"/api/execute-luau": MetadataHandlers.executeLuau,
+	"/api/eval-runtime": EvalRuntimeHandlers.evalRuntime,
 	"/api/undo": MetadataHandlers.undo,
 	"/api/redo": MetadataHandlers.redo,
 	"/api/bulk-set-attributes": MetadataHandlers.bulkSetAttributes,
@@ -485,18 +487,10 @@ function activatePlugin(connIndex?: number) {
 	// 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.
+	// Remove legacy edit-mode eval bridge scripts from older plugin builds.
+	// Current bridges are created only in running play DataModels.
 	if (!RunService.IsRunning()) {
-		task.spawn(() => {
-			const result = ensureBridgesInstalled();
-			if (!result.installed) {
-				warn(`[MCPPlugin] Eval bridge install failed: ${result.error}`);
-			}
-		});
+		task.spawn(cleanupLegacyEditBridges);
 	}
 
 	// Watch for game.Name updates so a stale "Place1" captured at first

package/studio-plugin/src/modules/EvalBridges.ts

@@ -21,30 +21,13 @@
 // ServerScriptService.LoadStringEnabled, so eval_server_runtime works even
 // when LoadStringEnabled=false (the default in fresh places).
 //
-// 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
-// never reached the play DMs because we'd set them to false). We now keep
-// Archivable=true so the clone works, and rely on cleanupBridges() to
-// remove the scripts from the edit DM when the test ends. The only failure
-// mode is the user saving DURING an active playtest, which would persist
-// the bridges to the .rbxl - that's a no-op next session because
-// installBridges() always calls cleanupBridges() first to clear stale
-// instances. The RemoteFunction/BindableFunction that the bridge scripts
-// CREATE at runtime stay Archivable=false (they're runtime-only and should
-// never appear in a save).
-
-import { ServerScriptService, StarterPlayer } from "@rbxts/services";
+// Lifecycle: bridge scripts are created only in running play DataModels.
+// The server plugin peer creates the Script in runtime ServerScriptService;
+// each client plugin peer creates its LocalScript in that client's
+// PlayerScripts. Nothing is installed into the edit DataModel anymore.
+// Runtime-created scripts disappear naturally when the playtest stops.
+
+import { Players, ReplicatedStorage, RunService, ServerScriptService, StarterPlayer } from "@rbxts/services";
 
 const ScriptEditorService = game.GetService("ScriptEditorService");
 
@@ -86,9 +69,10 @@ bf.Archivable = false
 bf.Parent = ServerScriptService
 bf.OnInvoke = function(payload)
 	if typeof(payload) ~= "Instance" or not payload:IsA("ModuleScript") then
-		return false, "payload must be a ModuleScript instance"
+		return { ok = false, value = "payload must be a ModuleScript instance" }
 	end
-	return pcall(require, payload)
+	local ok, value = pcall(require, payload)
+	return { ok = ok, value = value }
 end
 `;
 
@@ -113,19 +97,18 @@ bf.Archivable = false
 bf.Parent = ReplicatedStorage
 bf.OnInvoke = function(payload)
 	if typeof(payload) ~= "Instance" or not payload:IsA("ModuleScript") then
-		return false, "payload must be a ModuleScript instance"
+		return { ok = false, value = "payload must be a ModuleScript instance" }
 	end
-	return pcall(require, payload)
+	local ok, value = pcall(require, payload)
+	return { ok = ok, value = value }
 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).
+// runtime bridge currently in the play 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 and triggers a
+// runtime refresh instead of keeping a stale bridge.
 const STAMP_ATTR = "__MCPBridgeStamp";
 
 function computeBridgeStamp(): string {
@@ -153,7 +136,12 @@ function setSource(scriptInst: Script | LocalScript, source: string): void {
 	}
 }
 
-function findBridges(): { server?: Instance; client?: Instance } {
+interface InstallResult {
+	installed: boolean;
+	error?: string;
+}
+
+function findLegacyEditBridges(): { server?: Instance; client?: Instance } {
 	const sps = getStarterPlayerScripts();
 	return {
 		server: ServerScriptService.FindFirstChild(SERVER_SCRIPT_NAME),
@@ -161,8 +149,16 @@ function findBridges(): { server?: Instance; client?: Instance } {
 	};
 }
 
-export function cleanupBridges(): void {
-	const { server, client } = findBridges();
+function destroyIfPresent(parent: Instance, name: string): void {
+	const existing = parent.FindFirstChild(name);
+	if (existing) {
+		pcall(() => existing.Destroy());
+	}
+}
+
+export function cleanupLegacyEditBridges(): void {
+	if (RunService.IsRunning()) return;
+	const { server, client } = findLegacyEditBridges();
 	if (server) {
 		pcall(() => server.Destroy());
 	}
@@ -171,52 +167,75 @@ export function cleanupBridges(): void {
 	}
 }
 
-// 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.
-export function ensureBridgesInstalled(): { installed: boolean; error?: string } {
-	const { server, client } = findBridges();
-	if (server && client) {
-		// 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.
-		const sStamp = server.GetAttribute(STAMP_ATTR);
-		const cStamp = client.GetAttribute(STAMP_ATTR);
-		if (sStamp === BRIDGE_STAMP && cStamp === BRIDGE_STAMP) {
-			return { installed: true };
-		}
+function serverRuntimeBridgeReady(): boolean {
+	const scriptInst = ServerScriptService.FindFirstChild(SERVER_SCRIPT_NAME);
+	const bindable = ServerScriptService.FindFirstChild(BRIDGE_NAMES.serverLocal);
+	return scriptInst !== undefined &&
+		scriptInst.GetAttribute(STAMP_ATTR) === BRIDGE_STAMP &&
+		bindable !== undefined &&
+		bindable.IsA("BindableFunction");
+}
+
+function getPlayerScripts(): Instance | undefined {
+	const localPlayer = Players.LocalPlayer;
+	if (!localPlayer) return undefined;
+	let playerScripts = localPlayer.FindFirstChild("PlayerScripts");
+	if (!playerScripts) {
+		playerScripts = localPlayer.WaitForChild("PlayerScripts", 5);
 	}
-	return installBridges();
+	return playerScripts;
+}
+
+function clientRuntimeBridgeReady(): boolean {
+	const playerScripts = getPlayerScripts();
+	if (!playerScripts) return false;
+	const scriptInst = playerScripts.FindFirstChild(CLIENT_SCRIPT_NAME);
+	const bindable = ReplicatedStorage.FindFirstChild(BRIDGE_NAMES.clientLocal);
+	return scriptInst !== undefined &&
+		scriptInst.GetAttribute(STAMP_ATTR) === BRIDGE_STAMP &&
+		bindable !== undefined &&
+		bindable.IsA("BindableFunction");
 }
 
-export function installBridges(): { installed: boolean; error?: string } {
-	// 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
-	// containing Script/LocalScript objects themselves we must clear here.
-	cleanupBridges();
+function installServerRuntimeBridge(): InstallResult {
+	if (serverRuntimeBridgeReady()) return { installed: true };
 
 	const [ok, err] = pcall(() => {
+		destroyIfPresent(ServerScriptService, SERVER_SCRIPT_NAME);
+		destroyIfPresent(ServerScriptService, BRIDGE_NAMES.serverLocal);
+
 		const serverScript = new Instance("Script");
 		serverScript.Name = SERVER_SCRIPT_NAME;
-		// Archivable=true so ExecutePlayModeAsync's deep-clone includes the
-		// script. cleanupBridges() removes it from the edit DM when the
-		// playtest ends.
+		serverScript.Archivable = false;
 		setSource(serverScript, SERVER_BRIDGE_SOURCE);
 		serverScript.SetAttribute(STAMP_ATTR, BRIDGE_STAMP);
 		serverScript.Parent = ServerScriptService;
+	});
+
+	if (!ok) {
+		return { installed: false, error: tostring(err) };
+	}
+	return { installed: true };
+}
+
+function installClientRuntimeBridge(): InstallResult {
+	if (clientRuntimeBridgeReady()) return { installed: true };
+
+	const playerScripts = getPlayerScripts();
+	if (!playerScripts) {
+		return { installed: false, error: "Players.LocalPlayer.PlayerScripts not found - cannot install client eval bridge" };
+	}
+
+	const [ok, err] = pcall(() => {
+		destroyIfPresent(playerScripts, CLIENT_SCRIPT_NAME);
+		destroyIfPresent(ReplicatedStorage, BRIDGE_NAMES.clientLocal);
 
-		const sps = getStarterPlayerScripts();
-		if (!sps) {
-			error("StarterPlayer.StarterPlayerScripts not found - cannot install client eval bridge");
-		}
 		const clientScript = new Instance("LocalScript");
 		clientScript.Name = CLIENT_SCRIPT_NAME;
+		clientScript.Archivable = false;
 		setSource(clientScript, CLIENT_BRIDGE_SOURCE);
 		clientScript.SetAttribute(STAMP_ATTR, BRIDGE_STAMP);
-		clientScript.Parent = sps;
+		clientScript.Parent = playerScripts;
 	});
 
 	if (!ok) {
@@ -225,3 +244,12 @@ export function installBridges(): { installed: boolean; error?: string } {
 	return { installed: true };
 }
 
+export function ensureRuntimeBridgeInstalled(): InstallResult {
+	if (!RunService.IsRunning()) {
+		return { installed: false, error: "Eval bridges are installed only in running play DataModels" };
+	}
+	if (RunService.IsServer()) {
+		return installServerRuntimeBridge();
+	}
+	return installClientRuntimeBridge();
+}

package/studio-plugin/src/modules/LuauExec.ts

@@ -3,10 +3,12 @@
 // 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").
+//   1. The IIFE wrapper that captures print/warn, wraps require() so nested
+//      ModuleScript load failures can recover the real LogService diagnostic,
+//      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.
@@ -40,15 +42,15 @@ interface ExecuteResult {
 }
 
 const PAYLOAD_INSTANCE_NAME = "__MCPExecLuauPayload";
-const PAYLOAD_PATH_PREFIX = `Workspace.${PAYLOAD_INSTANCE_NAME}:`;
+const REQUIRE_GENERIC_ERROR = "Requested module experienced an error while loading";
 
 // 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.
-const WRAPPER_LINE_OFFSET = 23;
+// "line 49" the wrapper would otherwise expose. If you reorder buildWrapper's
+// prefix lines, update this constant.
+const WRAPPER_LINE_OFFSET = 84;
 
 // Count source lines so the wrapper can filter traceback frames that fall
 // outside the user code range (the wrapper's own preamble/postamble lines).
@@ -61,20 +63,29 @@ function countLines(s: string): number {
 	return n;
 }
 
-function buildWrapper(code: string): string {
+function luaPatternEscape(s: string): string {
+	const [escaped] = string.gsub(s, "([^%w])", "%%%1");
+	return escaped;
+}
+
+function buildWrapper(code: string, payloadInstanceName = PAYLOAD_INSTANCE_NAME): string {
 	// 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.
 	const userLines = countLines(code);
+	const payloadPattern = luaPatternEscape(payloadInstanceName);
 	return `return ((function()
 \tlocal __mcp_traceback
 \tlocal __mcp_remap
 \tlocal __mcp_LINE_OFFSET = ${WRAPPER_LINE_OFFSET}
 \tlocal __mcp_USER_LINES = ${userLines}
+\tlocal __mcp_LogService = game:GetService("LogService")
+\tlocal __mcp_REQUIRE_GENERIC = "${REQUIRE_GENERIC_ERROR}"
 \tlocal __mcp_output = {}
 \tlocal __mcp_real_print = print
 \tlocal __mcp_real_warn = warn
+\tlocal __mcp_real_require = require
 \tlocal print = function(...)
 \t\t__mcp_real_print(...)
 \t\tlocal args = {...}
@@ -89,6 +100,64 @@ function buildWrapper(code: string): string {
 \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_is_stack_noise(msg)
+\t\treturn msg == "Stack Begin" or msg == "Stack End" or string.sub(msg, 1, 8) == "Script '"
+\tend
+\tlocal function __mcp_is_actionable_require_log(entry)
+\t\tif not entry or entry.messageType ~= Enum.MessageType.MessageError then return false end
+\t\tlocal msg = tostring(entry.message)
+\t\treturn msg ~= __mcp_REQUIRE_GENERIC and not __mcp_is_stack_noise(msg)
+\tend
+\tlocal function __mcp_entry_mentions_module(entry, module_path)
+\t\tif not entry or not module_path or module_path == "" then return false end
+\t\treturn string.find(tostring(entry.message), module_path, 1, true) ~= nil
+\tend
+\tlocal function __mcp_prior_module_error(hist, module_path)
+\t\tif not module_path or module_path == "" then return nil end
+\t\tfor i = #hist, 1, -1 do
+\t\t\tlocal entry = hist[i]
+\t\t\tif __mcp_entry_mentions_module(entry, module_path) then
+\t\t\t\tif __mcp_is_actionable_require_log(entry) then
+\t\t\t\t\treturn tostring(entry.message)
+\t\t\t\tend
+\t\t\t\tfor j = i - 1, math.max(1, i - 6), -1 do
+\t\t\t\t\tlocal previous = hist[j]
+\t\t\t\t\tif __mcp_is_actionable_require_log(previous) then
+\t\t\t\t\t\treturn tostring(previous.message)
+\t\t\t\t\tend
+\t\t\t\tend
+\t\t\tend
+\t\tend
+\t\treturn nil
+\tend
+\tlocal function __mcp_recover_require_error(err, history_start, module)
+\t\tlocal err_msg = tostring(err)
+\t\tif err_msg ~= __mcp_REQUIRE_GENERIC then return err_msg end
+\t\tlocal module_path
+\t\tif typeof(module) == "Instance" then
+\t\t\tlocal ok_path, path = pcall(function()
+\t\t\t\treturn module:GetFullName()
+\t\t\tend)
+\t\t\tif ok_path then module_path = path end
+\t\tend
+\t\ttask.wait(0.05)
+\t\tlocal hist = __mcp_LogService:GetLogHistory()
+\t\tfor i = #hist, history_start + 1, -1 do
+\t\t\tlocal entry = hist[i]
+\t\t\tif __mcp_is_actionable_require_log(entry) then
+\t\t\t\treturn tostring(entry.message)
+\t\t\tend
+\t\tend
+\t\tlocal prior = __mcp_prior_module_error(hist, module_path)
+\t\tif prior then return prior end
+\t\treturn err_msg
+\tend
+\tlocal function require(module)
+\t\tlocal history_start = #__mcp_LogService:GetLogHistory()
+\t\tlocal ok, value = pcall(__mcp_real_require, module)
+\t\tif ok then return value end
+\t\terror(__mcp_recover_require_error(value, history_start, module), 0)
+\tend
 \tlocal function __mcp_run()
 ${code}
 \tend
@@ -99,15 +168,20 @@ ${code}
 \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\t-- line past user EOF. Without clamping, that frames wrapper postamble
+\t\t-- 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\ts = string.gsub(s, "Workspace%.${payloadPattern}:(%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, "${payloadPattern}:(%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
@@ -158,7 +232,7 @@ end)())`;
 // 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.
-function remapPayloadLines(s: string, userLines: number): string {
+function remapPayloadLines(s: string, userLines: number, payloadInstanceName = PAYLOAD_INSTANCE_NAME): string {
 	// 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
@@ -172,20 +246,26 @@ function remapPayloadLines(s: string, userLines: number): string {
 		if (u > userLines) return `${tostring(userLines)} (at end of input)`;
 		return tostring(u);
 	};
+	const payloadPattern = luaPatternEscape(payloadInstanceName);
 	let out = s;
-	const [a] = string.gsub(out, "__MCPExecLuauPayload:(%d+)", (num: string) => {
+	const [a] = string.gsub(out, `Workspace%.${payloadPattern}:(%d+)`, (num: string) => {
 		const n = tonumber(num);
 		if (n !== undefined) return `user_code:${userLine(n)}`;
 		return `user_code:${num}`;
 	});
 	out = a;
-	const [b] = string.gsub(out, '%[string "[^"]+"%]:(%d+)', (num: string) => {
+	const [b] = string.gsub(out, `${payloadPattern}:(%d+)`, (num: string) => {
 		const n = tonumber(num);
 		if (n !== undefined) return `user_code:${userLine(n)}`;
 		return `user_code:${num}`;
 	});
 	out = b;
-	return out;
+	const [c] = string.gsub(out, '%[string "[^"]+"%]:(%d+)', (num: string) => {
+		const n = tonumber(num);
+		if (n !== undefined) return `user_code:${userLine(n)}`;
+		return `user_code:${num}`;
+	});
+	return c;
 }
 
 function runViaModuleScript(wrapped: string, userLines: number): WrapperResult {
@@ -205,29 +285,11 @@ function runViaModuleScript(wrapped: string, userLines: number): WrapperResult {
 	const [okReq, reqResult] = pcall(() => require(m));
 	m.Destroy();
 	if (!okReq) {
-		let 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") {
-			task.wait(0.05);
-			const hist = LogService.GetLogHistory();
-			for (let i = hist.size() - 1; i >= 0; i--) {
-				const e = hist[i];
-				if (
-					e.messageType === Enum.MessageType.MessageError &&
-					string.sub(e.message, 1, PAYLOAD_PATH_PREFIX.size()) === PAYLOAD_PATH_PREFIX
-				) {
-					errMsg = e.message;
-					break;
-				}
-			}
-		}
 		// 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);
+		error(recoverPayloadRequireError(reqResult, userLines, PAYLOAD_INSTANCE_NAME), 0);
 	}
 	return reqResult as unknown as WrapperResult;
 }
@@ -250,6 +312,35 @@ function formatReturnValue(value: unknown): string {
 	return tostring(value);
 }
 
+function recoverPayloadRequireError(
+	err: unknown,
+	userLines: number,
+	payloadInstanceName = PAYLOAD_INSTANCE_NAME,
+	historyStart = 0,
+): string {
+	let errMsg = tostring(err);
+	// pcall(require, m) collapses parse/compile failures into the canned
+	// engine string. The real diagnostic is emitted to LogService on the
+	// next engine frame — give it ~50ms to land then scan backward.
+	if (errMsg === REQUIRE_GENERIC_ERROR) {
+		task.wait(0.05);
+		const payloadPathPrefix = `Workspace.${payloadInstanceName}:`;
+		const hist = LogService.GetLogHistory();
+		const start = math.max(0, historyStart);
+		for (let i = hist.size() - 1; i >= start; i--) {
+			const e = hist[i];
+			if (
+				e.messageType === Enum.MessageType.MessageError &&
+				string.sub(e.message, 1, payloadPathPrefix.size()) === payloadPathPrefix
+			) {
+				errMsg = e.message;
+				break;
+			}
+		}
+	}
+	return remapPayloadLines(errMsg, userLines, payloadInstanceName);
+}
+
 function execute(code: string): ExecuteResult {
 	if (!code || code === "") {
 		return { success: false, error: "code is required" };
@@ -302,4 +393,11 @@ function execute(code: string): ExecuteResult {
 	};
 }
 
-export = { execute };
+export = {
+	buildWrapper,
+	countLines,
+	execute,
+	formatReturnValue,
+	recoverPayloadRequireError,
+	remapPayloadLines,
+};

package/studio-plugin/src/modules/RuntimeLogBuffer.ts

@@ -1,4 +1,4 @@
-// Per-peer in-memory ring buffer for LogService.MessageOut events.
+// Per-capture in-memory ring buffer for LogService.MessageOut events.
 // Powers the get_runtime_logs MCP tool. Replaces the out-of-tree LogBuffer
 // primitives + StringValue approach from chrrxs/roblox-mcp-primitives.
 //
@@ -8,12 +8,12 @@
 // DataModel. The buffer is bounded by a message-byte budget; oldest entries
 // drop when over budget.
 //
-// Peer-tag caveat: returned entries reflect which peer's plugin CAPTURED the
+// Capture caveat: returned entries reflect which plugin buffer CAPTURED the
 // entry, NOT which peer's script originated the print. LogService reflects
-// prints across peers in Studio Play (a server print ends up in both the
-// server and client LogService:GetLogHistory()) and origin is empirically
-// undetectable from inside MessageOut. The MCP-side aggregator handles
-// cross-peer dedup via a 2s timestamp window.
+// prints across peers in ordinary Studio Play (a server print can appear in
+// server and client LogService:GetLogHistory()). The MCP-side aggregator
+// exposes that as capturedBy, and only promotes it to origin peer in
+// StudioTestService multiplayer sessions where peer attribution is reliable.
 
 import { LogService, RunService } from "@rbxts/services";
 
@@ -88,13 +88,13 @@ interface QueryOptions {
 }
 
 interface QueryResult {
-	peer: string;
+	capturedBy: string;
 	entries: RuntimeLogEntry[];
 	totalDropped: number;
 	nextSince: number;
 }
 
-function query(opts: QueryOptions, peer: string): QueryResult {
+function query(opts: QueryOptions, capturedBy: string): QueryResult {
 	let result = opts.since !== undefined
 		? entries.filter((e) => e.seq > (opts.since as number))
 		: [...entries];
@@ -124,7 +124,7 @@ function query(opts: QueryOptions, peer: string): QueryResult {
 
 	const last = entries.size() > 0 ? entries[entries.size() - 1] : undefined;
 	return {
-		peer,
+		capturedBy,
 		entries: result,
 		totalDropped,
 		nextSince: last ? last.seq : (opts.since ?? 0),