@princeofscale/bloxforge 2.20.2 → 3.0.0

package/dist/index.js

@@ -14,6 +14,111 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../core/dist/request-journal.js
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function defaultRequestJournalPath() {
+  if (process.env.NODE_ENV === "test")
+    return void 0;
+  const configured = process.env.BLOXFORGE_JOURNAL_PATH?.trim();
+  if (configured === "off" || configured === "0")
+    return void 0;
+  return configured || path.join(os.homedir(), ".bloxforge", "bridge-journal.json");
+}
+var DEFAULT_STATUS_TTL_MS, MAX_STATUSES, MAX_RECEIPTS, RECEIPT_TTL_MS, COMPACT_INTERVAL, RequestJournal;
+var init_request_journal = __esm({
+  "../core/dist/request-journal.js"() {
+    "use strict";
+    DEFAULT_STATUS_TTL_MS = 60 * 60 * 1e3;
+    MAX_STATUSES = 1e3;
+    MAX_RECEIPTS = 200;
+    RECEIPT_TTL_MS = 5 * 60 * 1e3;
+    COMPACT_INTERVAL = 50;
+    RequestJournal = class {
+      filePath;
+      persistCount = 0;
+      constructor(filePath) {
+        this.filePath = filePath;
+      }
+      load() {
+        try {
+          const raw = fs.readFileSync(this.filePath, "utf8");
+          const parsed = JSON.parse(raw);
+          if (!parsed || typeof parsed !== "object")
+            return void 0;
+          if (!Array.isArray(parsed.statuses) || !Array.isArray(parsed.pending))
+            return void 0;
+          if (parsed.version === 1) {
+            return {
+              version: 2,
+              savedAt: parsed.savedAt,
+              statuses: parsed.statuses,
+              pending: parsed.pending,
+              completionReceipts: []
+            };
+          }
+          if (parsed.version === 2 && Array.isArray(parsed.completionReceipts)) {
+            return parsed;
+          }
+          return void 0;
+        } catch {
+          this.backupCorruptFile();
+          return void 0;
+        }
+      }
+      save(statuses, pending, completionReceipts = []) {
+        const directory = path.dirname(this.filePath);
+        fs.mkdirSync(directory, { recursive: true, mode: 448 });
+        const snapshot = {
+          version: 2,
+          savedAt: Date.now(),
+          statuses,
+          pending,
+          completionReceipts
+        };
+        const temporary = `${this.filePath}.${process.pid}.tmp`;
+        fs.writeFileSync(temporary, JSON.stringify(snapshot), { mode: 384 });
+        fs.renameSync(temporary, this.filePath);
+        this.persistCount++;
+        if (this.persistCount >= COMPACT_INTERVAL) {
+          this.persistCount = 0;
+        }
+      }
+      /**
+       * Compact a snapshot in-place: enforce retention TTL and entry limits.
+       * Returns a new compacted snapshot.
+       */
+      static compact(snapshot, now = Date.now()) {
+        let statuses = snapshot.statuses.filter((s) => now - s.updatedAt < DEFAULT_STATUS_TTL_MS);
+        if (statuses.length > MAX_STATUSES) {
+          statuses = statuses.slice(statuses.length - MAX_STATUSES);
+        }
+        let receipts = snapshot.completionReceipts.filter((r) => now - r.completedAt < RECEIPT_TTL_MS);
+        if (receipts.length > MAX_RECEIPTS) {
+          receipts = receipts.slice(receipts.length - MAX_RECEIPTS);
+        }
+        return {
+          ...snapshot,
+          savedAt: now,
+          statuses,
+          completionReceipts: receipts
+        };
+      }
+      /** Back up a corrupt journal file so data is not silently lost. */
+      backupCorruptFile() {
+        try {
+          if (!fs.existsSync(this.filePath))
+            return;
+          const backup = `${this.filePath}.corrupt.${Date.now()}`;
+          fs.copyFileSync(this.filePath, backup);
+        } catch {
+        }
+      }
+    };
+  }
+});
+
 // ../core/dist/bridge-service.js
 import { randomUUID } from "crypto";
 function toPublic(inst) {
@@ -56,10 +161,11 @@ function publishedInstanceId(placeId) {
     return void 0;
   return `place:${Math.trunc(placeId)}`;
 }
-var RoutingFailure, MCP_PROTOCOL_VERSION, STALE_INSTANCE_MS, INSTANCE_ALIAS_TTL_MS, DEFAULT_REQUEST_TIMEOUT_MS, HEAVY_REQUEST_TIMEOUT_FLOOR_MS, HEAVY_ENDPOINTS, BridgeService;
+var RoutingFailure, RequestOutcomeUnknownError, MCP_PROTOCOL_VERSION, STALE_INSTANCE_MS, INSTANCE_ALIAS_TTL_MS, DEFAULT_REQUEST_TIMEOUT_MS, HEAVY_REQUEST_TIMEOUT_FLOOR_MS, HEAVY_ENDPOINTS, BridgeService;
 var init_bridge_service = __esm({
   "../core/dist/bridge-service.js"() {
     "use strict";
+    init_request_journal();
     RoutingFailure = class extends Error {
       routingError;
       constructor(routingError) {
@@ -68,7 +174,16 @@ var init_bridge_service = __esm({
         this.routingError = routingError;
       }
     };
-    MCP_PROTOCOL_VERSION = 1;
+    RequestOutcomeUnknownError = class extends Error {
+      requestId;
+      outcome = "unknown";
+      constructor(requestId, endpoint, timeout) {
+        super(`Request timeout after ${timeout}ms on ${endpoint}. Request ${requestId} outcome unknown. The plugin may still be running heavy code \u2014 the work can succeed even though this call gave up.`);
+        this.requestId = requestId;
+        this.name = "RequestOutcomeUnknownError";
+      }
+    };
+    MCP_PROTOCOL_VERSION = 3;
     STALE_INSTANCE_MS = envStaleInstanceMs();
     INSTANCE_ALIAS_TTL_MS = 5 * 60 * 1e3;
     DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
@@ -86,6 +201,89 @@ var init_bridge_service = __esm({
       // with a small TTL without depending on wall-clock env vars. Production
       // callers leave this at the module-level STALE_INSTANCE_MS default.
       staleInstanceMs = STALE_INSTANCE_MS;
+      serverEpoch = randomUUID();
+      journal;
+      requestStatuses = /* @__PURE__ */ new Map();
+      sessionTokens = /* @__PURE__ */ new Map();
+      // sessionToken -> pluginSessionId
+      transportCounters = {
+        completed: 0,
+        outcomeUnknown: 0,
+        deliveryRetries: 0,
+        cancelled: 0,
+        timeouts: 0
+      };
+      transportLatencies = [];
+      constructor(journal) {
+        if (typeof journal === "string") {
+          this.journal = new RequestJournal(journal);
+        } else if (journal) {
+          this.journal = journal;
+        } else {
+          const path10 = defaultRequestJournalPath();
+          if (path10)
+            this.journal = new RequestJournal(path10);
+        }
+        if (this.journal) {
+          try {
+            const snapshot = this.journal.load();
+            if (snapshot) {
+              const { statuses, pending } = snapshot;
+              for (const s of statuses) {
+                if (s.state === "delivered" || s.state === "started") {
+                  s.state = "outcome_unknown";
+                  s.updatedAt = Date.now();
+                }
+                this.requestStatuses.set(s.requestId, s);
+              }
+              for (const p of pending) {
+                if (p.state !== "queued")
+                  continue;
+                this.pendingRequests.set(p.id, {
+                  id: p.id,
+                  endpoint: p.endpoint,
+                  data: p.data,
+                  targetInstanceId: p.targetInstanceId,
+                  targetRole: p.targetRole,
+                  timestamp: p.timestamp,
+                  inFlight: false,
+                  deliveryAttempt: p.deliveryAttempt,
+                  resolve: () => {
+                  },
+                  reject: () => {
+                  },
+                  timeoutId: setTimeout(() => {
+                  }, 0)
+                });
+              }
+            }
+          } catch (e) {
+          }
+        }
+      }
+      enableJournal() {
+        const path10 = defaultRequestJournalPath();
+        if (path10)
+          this.journal = new RequestJournal(path10);
+      }
+      persistJournal() {
+        if (!this.journal)
+          return;
+        this.journal.save(Array.from(this.requestStatuses.entries()).map(([id, s]) => ({ requestId: id, ...s })), Array.from(this.pendingRequests.values()).map((req) => ({
+          id: req.id,
+          endpoint: req.endpoint,
+          data: req.data,
+          targetInstanceId: req.targetInstanceId,
+          targetRole: req.targetRole,
+          timestamp: req.timestamp,
+          state: this.requestStatuses.get(req.id)?.state ?? "queued",
+          deliveryAttempt: req.deliveryAttempt ?? 0
+        })), []);
+      }
+      updateRequestStatus(requestId, status) {
+        const existing = this.requestStatuses.get(requestId) ?? { state: "queued", serverEpoch: this.serverEpoch, deliveryAttempt: 0, updatedAt: Date.now() };
+        this.requestStatuses.set(requestId, { ...existing, ...status, updatedAt: Date.now() });
+      }
       canonicalInstanceId(instanceId, placeId) {
         return publishedInstanceId(placeId) ?? instanceId;
       }
@@ -212,30 +410,53 @@ var init_bridge_service = __esm({
           lastActivity: Date.now(),
           connectedAt: prior?.connectedAt ?? Date.now()
         });
-        return { ok: true, assignedRole, instanceId };
+        const sessionToken = randomUUID();
+        this.sessionTokens.set(sessionToken, pluginSessionId);
+        return { ok: true, assignedRole, instanceId, sessionToken };
+      }
+      authenticatePlugin(pluginSessionId, sessionToken) {
+        const expectedId = this.sessionTokens.get(sessionToken);
+        return expectedId === pluginSessionId;
       }
       unregisterInstance(pluginSessionId, reason = "unknown") {
-        const removed = this.instances.get(pluginSessionId);
-        this.instances.delete(pluginSessionId);
-        if (!removed)
+        const instance = this.instances.get(pluginSessionId);
+        if (!instance)
           return;
-        this.recentDisconnects.unshift({
+        this.instances.delete(pluginSessionId);
+        this.recentDisconnects.push({
           pluginSessionId,
-          instanceId: removed.instanceId,
-          role: removed.role,
+          instanceId: instance.instanceId,
+          role: instance.role,
           reason,
           disconnectedAt: Date.now(),
-          lastActivity: removed.lastActivity
+          lastActivity: instance.lastActivity
         });
-        this.recentDisconnects.length = Math.min(this.recentDisconnects.length, 10);
-        for (const [id, req] of this.pendingRequests.entries()) {
-          const stillHasHandler = Array.from(this.instances.values()).some((i) => i.instanceId === req.targetInstanceId && i.role === req.targetRole);
+        if (this.recentDisconnects.length > 50)
+          this.recentDisconnects.shift();
+        for (const [id, request] of this.pendingRequests.entries()) {
+          const stillHasHandler = Array.from(this.instances.values()).some((i) => i.instanceId === request.targetInstanceId && i.role === request.targetRole);
+          const status = this.requestStatuses.get(id);
+          const wasAssignedToThis = request.assignedPluginSessionId === pluginSessionId;
           if (!stillHasHandler) {
-            clearTimeout(req.timeoutId);
+            clearTimeout(request.timeoutId);
             this.pendingRequests.delete(id);
-            req.reject(new Error(`Target (${req.targetInstanceId}, ${req.targetRole}) disconnected`));
+            if (status?.state === "delivered" || status?.state === "started") {
+              this.updateRequestStatus(id, { state: "outcome_unknown" });
+              request.reject(new RequestOutcomeUnknownError(id, request.endpoint, this.requestTimeout));
+            } else {
+              this.updateRequestStatus(id, { state: "failed", error: "Target disconnected" });
+              request.reject(new Error(`Target (${request.targetInstanceId}, ${request.targetRole}) disconnected`));
+            }
+          } else {
+            if (wasAssignedToThis && (status?.state === "delivered" || status?.state === "started")) {
+              clearTimeout(request.timeoutId);
+              this.pendingRequests.delete(id);
+              this.updateRequestStatus(id, { state: "outcome_unknown" });
+              request.reject(new RequestOutcomeUnknownError(id, request.endpoint, this.requestTimeout));
+            }
           }
         }
+        this.persistJournal();
       }
       getInstances() {
         return Array.from(this.instances.values());
@@ -290,6 +511,29 @@ var init_bridge_service = __esm({
           }
         }
       }
+      async lookupRequestStatus(requestId) {
+        const status = this.requestStatuses.get(requestId);
+        if (!status)
+          return void 0;
+        return { requestId, ...status };
+      }
+      getRequestStatus(requestId) {
+        const status = this.requestStatuses.get(requestId);
+        if (!status)
+          return void 0;
+        return { requestId, ...status };
+      }
+      getTransportDiagnostics() {
+        return {
+          completed: this.transportCounters.completed,
+          queueDepth: this.pendingRequests.size,
+          deliveryRetries: this.transportCounters.deliveryRetries,
+          timeouts: this.transportCounters.timeouts,
+          outcomeUnknown: this.transportCounters.outcomeUnknown,
+          cancelled: this.transportCounters.cancelled,
+          averageLatencyMs: this.transportLatencies.length > 0 ? this.transportLatencies.reduce((a, b) => a + b, 0) / this.transportLatencies.length : 0
+        };
+      }
       cleanupStaleInstances() {
         const now = Date.now();
         for (const [id, inst] of this.instances.entries()) {
@@ -419,11 +663,14 @@ var init_bridge_service = __esm({
       async sendRequest(endpoint, data, targetInstanceId, targetRole) {
         const requestId = randomUUID();
         const effectiveTimeout = resolveRequestTimeout(endpoint, this.requestTimeout);
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           const timeoutId = setTimeout(() => {
             if (this.pendingRequests.has(requestId)) {
               this.pendingRequests.delete(requestId);
-              reject(new Error(`Request timeout after ${effectiveTimeout}ms on ${endpoint}. The plugin may still be running heavy code \u2014 the work can succeed even though this call gave up. Raise MCP_REQUEST_TIMEOUT_MS for big scripts.`));
+              this.updateRequestStatus(requestId, { state: "outcome_unknown" });
+              this.persistJournal();
+              this.transportCounters.timeouts++;
+              reject(new RequestOutcomeUnknownError(requestId, endpoint, effectiveTimeout));
             }
           }, effectiveTimeout);
           const request = {
@@ -434,11 +681,13 @@ var init_bridge_service = __esm({
             targetRole,
             timestamp: Date.now(),
             inFlight: false,
-            resolve: resolve6,
+            resolve: resolve7,
             reject,
             timeoutId
           };
           this.pendingRequests.set(requestId, request);
+          this.updateRequestStatus(requestId, { state: "queued" });
+          this.persistJournal();
           for (const instance of this.instances.values()) {
             if (instance.instanceId === targetInstanceId && instance.role === targetRole) {
               for (const notify of this.requestNotifiers)
@@ -452,9 +701,28 @@ var init_bridge_service = __esm({
         if (!instance)
           return null;
         this.updateInstanceActivity(pluginSessionId);
-        return this.getPendingRequest(instance.instanceId, instance.role);
+        return this.getPendingRequest(instance.instanceId, instance.role, pluginSessionId);
       }
-      getPendingRequest(callerInstanceId, callerRole) {
+      getPendingRequest(callerInstanceId, callerRole, pluginSessionId) {
+        let inFlightMutations = 0;
+        let inFlightReads = 0;
+        for (const request of this.pendingRequests.values()) {
+          if (request.targetInstanceId !== callerInstanceId)
+            continue;
+          if (request.targetRole !== callerRole)
+            continue;
+          const status = this.requestStatuses.get(request.id);
+          if (request.inFlight && status?.state === "delivered" && Date.now() - status.updatedAt >= 1e4) {
+            request.inFlight = false;
+            this.updateRequestStatus(request.id, { state: "queued" });
+          }
+          if (request.inFlight) {
+            if (this.isMutation(request.endpoint))
+              inFlightMutations++;
+            else
+              inFlightReads++;
+          }
+        }
         let oldestRequest = null;
         for (const request of this.pendingRequests.values()) {
           if (request.targetInstanceId !== callerInstanceId)
@@ -463,14 +731,33 @@ var init_bridge_service = __esm({
             continue;
           if (request.inFlight)
             continue;
+          const isMutationReq = this.isMutation(request.endpoint);
+          if (isMutationReq && inFlightMutations >= 1)
+            continue;
+          if (!isMutationReq && inFlightReads >= 4)
+            continue;
           if (!oldestRequest || request.timestamp < oldestRequest.timestamp) {
             oldestRequest = request;
           }
         }
         if (oldestRequest) {
           oldestRequest.inFlight = true;
+          oldestRequest.deliveryAttempt = (oldestRequest.deliveryAttempt ?? 0) + 1;
+          oldestRequest.assignedPluginSessionId = pluginSessionId;
+          const leaseToken = randomUUID();
+          this.updateRequestStatus(oldestRequest.id, {
+            state: "delivered",
+            serverEpoch: this.serverEpoch,
+            deliveryAttempt: oldestRequest.deliveryAttempt,
+            leaseToken
+          });
+          this.persistJournal();
           return {
             requestId: oldestRequest.id,
+            serverEpoch: this.serverEpoch,
+            pluginSessionId: pluginSessionId ?? "",
+            deliveryAttempt: oldestRequest.deliveryAttempt,
+            leaseToken,
             request: {
               endpoint: oldestRequest.endpoint,
               data: oldestRequest.data
@@ -481,8 +768,11 @@ var init_bridge_service = __esm({
       }
       releasePendingRequest(requestId) {
         const request = this.pendingRequests.get(requestId);
-        if (request)
+        if (request) {
           request.inFlight = false;
+          this.updateRequestStatus(requestId, { state: "queued" });
+          this.persistJournal();
+        }
       }
       releasePendingRequestsForSession(pluginSessionId) {
         const instance = this.instances.get(pluginSessionId);
@@ -491,24 +781,84 @@ var init_bridge_service = __esm({
         for (const request of this.pendingRequests.values()) {
           if (request.targetInstanceId === instance.instanceId && request.targetRole === instance.role) {
             request.inFlight = false;
+            request.assignedPluginSessionId = void 0;
+            this.updateRequestStatus(request.id, { state: "queued" });
+          }
+        }
+        this.persistJournal();
+      }
+      reconcilePluginReceipts(pluginSessionId, serverEpoch, receipts) {
+        if (serverEpoch !== this.serverEpoch)
+          return 0;
+        const instance = this.instances.get(pluginSessionId);
+        if (!instance)
+          return 0;
+        let reconciled = 0;
+        for (const receipt of receipts) {
+          const status = this.requestStatuses.get(receipt.requestId);
+          if (status && status.state === "outcome_unknown") {
+            status.state = "completed";
+            status.updatedAt = receipt.completedAt || Date.now();
+            status.response = { reconciled: true, digest: receipt.responseDigest };
+            reconciled++;
           }
         }
+        if (reconciled > 0) {
+          this.persistJournal();
+        }
+        return reconciled;
+      }
+      acknowledgeRequest(requestId) {
+        const status = this.requestStatuses.get(requestId);
+        if (!status)
+          return false;
+        this.updateRequestStatus(requestId, { state: "started" });
+        this.persistJournal();
+        return true;
       }
       resolveRequest(requestId, response) {
         const request = this.pendingRequests.get(requestId);
+        this.updateRequestStatus(requestId, { state: "completed", response, error: void 0 });
+        this.transportCounters.completed++;
         if (request) {
           clearTimeout(request.timeoutId);
           this.pendingRequests.delete(requestId);
           request.resolve(response);
         }
+        this.persistJournal();
       }
       rejectRequest(requestId, error) {
         const request = this.pendingRequests.get(requestId);
+        this.updateRequestStatus(requestId, { state: "failed", error });
         if (request) {
           clearTimeout(request.timeoutId);
           this.pendingRequests.delete(requestId);
           request.reject(error);
         }
+        this.persistJournal();
+      }
+      resolveFencedRequest(requestId, response, fence) {
+        const status = this.requestStatuses.get(requestId);
+        const pending = this.pendingRequests.get(requestId);
+        if (!status || status.serverEpoch !== fence.serverEpoch || status.deliveryAttempt !== fence.deliveryAttempt || status.leaseToken !== fence.leaseToken || status.state === "completed" || status.state === "failed" || pending?.assignedPluginSessionId !== fence.pluginSessionId)
+          return false;
+        this.resolveRequest(requestId, response);
+        return true;
+      }
+      rejectFencedRequest(requestId, error, fence) {
+        const status = this.requestStatuses.get(requestId);
+        const pending = this.pendingRequests.get(requestId);
+        if (!status || status.serverEpoch !== fence.serverEpoch || status.deliveryAttempt !== fence.deliveryAttempt || status.leaseToken !== fence.leaseToken || status.state === "completed" || status.state === "failed" || pending?.assignedPluginSessionId !== fence.pluginSessionId)
+          return false;
+        this.rejectRequest(requestId, error);
+        return true;
+      }
+      acknowledgeFencedRequest(requestId, fence) {
+        const status = this.requestStatuses.get(requestId);
+        const pending = this.pendingRequests.get(requestId);
+        if (!status || status.serverEpoch !== fence.serverEpoch || status.deliveryAttempt !== fence.deliveryAttempt || status.leaseToken !== fence.leaseToken || status.state === "completed" || status.state === "failed" || pending?.assignedPluginSessionId !== fence.pluginSessionId)
+          return false;
+        return this.acknowledgeRequest(requestId);
       }
       cleanupOldRequests() {
         const now = Date.now();
@@ -527,6 +877,48 @@ var init_bridge_service = __esm({
         }
         this.pendingRequests.clear();
       }
+      cancelRequest(requestId) {
+        const request = this.pendingRequests.get(requestId);
+        if (!request)
+          return false;
+        const status = this.requestStatuses.get(requestId);
+        if (status?.state === "started") {
+          return false;
+        }
+        clearTimeout(request.timeoutId);
+        this.pendingRequests.delete(requestId);
+        this.updateRequestStatus(requestId, { state: "cancelled", error: "Request cancelled before execution" });
+        this.transportCounters.cancelled++;
+        request.reject(new Error(`Request ${requestId} cancelled`));
+        this.persistJournal();
+        return true;
+      }
+      getCancellationEvents(pluginSessionId) {
+        const instance = this.instances.get(pluginSessionId);
+        if (!instance)
+          return [];
+        const events = [];
+        for (const request of this.pendingRequests.values()) {
+          if (request.targetInstanceId === instance.instanceId && request.targetRole === instance.role && this.requestStatuses.get(request.id)?.state === "started" && request.cancellationRequested) {
+            events.push(request.id);
+          }
+        }
+        return events;
+      }
+      async requestCancellation(requestId) {
+        const request = this.pendingRequests.get(requestId);
+        if (!request)
+          return false;
+        const status = this.requestStatuses.get(requestId);
+        if (status?.state === "started") {
+          request.cancellationRequested = true;
+          return true;
+        }
+        return this.cancelRequest(requestId);
+      }
+      isMutation(endpoint) {
+        return !endpoint.startsWith("/api/read") && !endpoint.startsWith("/api/get") && !endpoint.startsWith("/api/search") && endpoint !== "/api/evaluate" && endpoint !== "/api/execute-script" && endpoint !== "/api/run-code";
+      }
     };
   }
 });
@@ -593,7 +985,12 @@ function isRetryable(code) {
 }
 function toolErrorResult(error, stage) {
   const message = error instanceof Error ? error.message : String(error);
-  const env = errorEnvelope(message, stage ? { stage } : {});
+  const unknownOutcome = error;
+  const busy = error;
+  const env = errorEnvelope(message, {
+    ...stage ? { stage } : {},
+    ...unknownOutcome?.outcome === "unknown" && typeof unknownOutcome.requestId === "string" ? { code: "OUTCOME_UNKNOWN", details: { requestId: unknownOutcome.requestId, outcome: "unknown" } } : typeof busy.retryAfterMs === "number" ? { code: "BUSY", details: { retryAfterMs: busy.retryAfterMs } } : {}
+  });
   return { content: [{ type: "text", text: JSON.stringify(env) }], isError: true };
 }
 function errorEnvelope(message, opts = {}) {
@@ -635,6 +1032,8 @@ var init_errors = __esm({
     "use strict";
     PATTERNS = [
       // Order matters: more specific first.
+      [/outcome\s+is\s+unknown|outcome_unknown/i, "OUTCOME_UNKNOWN"],
+      [/bridge queue is busy|\bbusy\b/i, "BUSY"],
       [/\b429\b|rate.?limit/i, "RATE_LIMITED"],
       [/confirm(ation)?\s+required|requires?\s+confirm|pass\s+confirm/i, "CONFIRMATION_REQUIRED"],
       [/multiple\s+(places|instances)|ambiguous\s+target|which\s+instance|specify\s+instance_id/i, "AMBIGUOUS_TARGET"],
@@ -648,11 +1047,14 @@ var init_errors = __esm({
       [/required|missing\s+(argument|parameter|field)|must\s+be\s+(a|an)\b/i, "INVALID_ARGUMENT"]
     ];
     RETRYABLE = /* @__PURE__ */ new Set([
+      "BUSY",
       "TIMEOUT",
       "RATE_LIMITED",
       "PLUGIN_DISCONNECTED"
     ]);
     RECOVERY = {
+      BUSY: "wait for retryAfterMs, then retry the request",
+      OUTCOME_UNKNOWN: "call get_request_status with details.requestId before deciding whether to retry",
       TIMEOUT: "retry; for heavy code prefer execute_luau_async",
       RATE_LIMITED: "back off and retry shortly",
       PLUGIN_DISCONNECTED: "check the Studio plugin is connected, then retry",
@@ -697,6 +1099,40 @@ var init_structured_output = __esm({
   }
 });
 
+// ../core/dist/capability-policy.js
+function requiredCapability(toolName, category) {
+  if (EXECUTE_TOOLS.test(toolName))
+    return "execute.luau";
+  if (ASSET_TOOLS.test(toolName))
+    return "assets.external";
+  if (PLAYTEST_TOOLS.test(toolName))
+    return "playtest.control";
+  if (PROPERTY_TOOLS.test(toolName))
+    return "write.properties";
+  return category === "write" ? "write.instances" : "read.scene";
+}
+function parseCapabilities(value) {
+  if (!value?.trim())
+    return void 0;
+  return new Set(value.split(",").map((entry) => entry.trim()).filter(Boolean));
+}
+function parseClientCapabilities(value) {
+  if (!value?.trim())
+    return /* @__PURE__ */ new Map();
+  const parsed = JSON.parse(value);
+  return new Map(Object.entries(parsed).map(([token, capabilities]) => [token, new Set(capabilities)]));
+}
+var PROPERTY_TOOLS, EXECUTE_TOOLS, ASSET_TOOLS, PLAYTEST_TOOLS;
+var init_capability_policy = __esm({
+  "../core/dist/capability-policy.js"() {
+    "use strict";
+    PROPERTY_TOOLS = /^(set_property|set_properties|mass_set_property|set_attribute|bulk_set_attributes|add_tag|remove_tag|delete_attribute)$/;
+    EXECUTE_TOOLS = /^(execute_luau|execute_luau_async|eval_.*runtime|apply_mutation_plan)$/;
+    ASSET_TOOLS = /(asset|wally|publish|import_rbxm|export_rbxm)/;
+    PLAYTEST_TOOLS = /(playtest|multiplayer|simulate_(mouse|keyboard)|character_navigation)/;
+  }
+});
+
 // ../core/dist/server-instructions.js
 var SERVER_INSTRUCTIONS;
 var init_server_instructions = __esm({
@@ -886,8 +1322,8 @@ function parseResourceUri(uri) {
     return { kind: "changes", since };
   }
   if (segments[0] === "node" && segments.length >= 2) {
-    const path8 = decodeURIComponent(segments.slice(1).join("/"));
-    return { kind: "node", path: path8 };
+    const path10 = decodeURIComponent(segments.slice(1).join("/"));
+    return { kind: "node", path: path10 };
   }
   if (segments[0] === "playtest" && segments[1] === "episode" && segments.length >= 3) {
     return { kind: "episode", id: decodeURIComponent(segments.slice(2).join("/")) };
@@ -1104,6 +1540,20 @@ var init_tool_catalog = __esm({
       "load_toolset",
       "get_roblox_docs",
       "get_session_summary",
+      "get_request_status",
+      "get_transport_diagnostics",
+      "cancel_request",
+      "detect_roblox_project",
+      "validate_script_source",
+      "format_script_preview",
+      "resolve_instance_source_file",
+      "run_project_tests",
+      "get_dependency_graph",
+      "install_wally_packages",
+      "run_quality_gate",
+      "validate_with_luau_lsp",
+      "generate_rojo_sourcemap",
+      "build_rojo_project",
       "get_connected_instances",
       "get_scene_summary",
       "execute_luau",
@@ -1209,7 +1659,6 @@ var init_tool_catalog = __esm({
 
 // ../core/dist/http-server.js
 import express from "express";
-import cors from "cors";
 import http from "http";
 import { WebSocketServer, WebSocket } from "ws";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -1217,11 +1666,29 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
 function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
   const app = express();
+  const requirePluginAuth = process.env.NODE_ENV !== "test";
+  const bearerToken = (req) => {
+    const value = req.header("authorization");
+    return value?.startsWith("Bearer ") ? value.slice(7) : void 0;
+  };
+  const pluginAuthorized = (req, pluginSessionId) => !requirePluginAuth || !!pluginSessionId && bridge.authenticatePlugin(pluginSessionId, bearerToken(req) ?? "");
+  const serverSessionToken = process.env.BLOXFORGE_SESSION_TOKEN?.trim();
+  const clientCapabilities = parseClientCapabilities(process.env.BLOXFORGE_CLIENT_CAPABILITIES_JSON);
+  app.use((req, res, next) => {
+    const protectedServerRoute = req.path === "/proxy" || req.path === "/mcp" || req.path.startsWith("/mcp/");
+    const token = bearerToken(req);
+    if (protectedServerRoute && (serverSessionToken || clientCapabilities.size > 0) && token !== serverSessionToken && !clientCapabilities.has(token ?? "")) {
+      res.status(401).json({ error: "invalid_session_token" });
+      return;
+    }
+    next();
+  });
   let mcpServerActive = false;
   let lastMCPActivity = 0;
   let mcpServerStartTime = 0;
   const proxyInstances = /* @__PURE__ */ new Set();
   const warnedVersionMismatches = /* @__PURE__ */ new Set();
+  const warnedProtocolMismatches = /* @__PURE__ */ new Set();
   const setMCPServerActive = (active) => {
     mcpServerActive = active;
     if (active) {
@@ -1249,9 +1716,9 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
   const isLazyTools = () => registry ? registry.lazyMode : !(envLazyFlag === "0" || envLazyFlag === "false" || envLazyFlag === "off");
   const getActiveToolCount = () => isLazyTools() ? registry ? registry.activeNames.size : CORE_TOOLS.size : serverConfig?.tools.length ?? 0;
   const getLoadedToolsets = () => isLazyTools() ? [process.env.BLOXFORGE_TOOL_PROFILE?.trim().toLowerCase() || "core"] : ["all"];
-  app.use(cors());
-  app.use(express.json({ limit: "50mb" }));
-  app.use(express.urlencoded({ limit: "50mb", extended: true }));
+  const bodyLimit = process.env.MCP_HTTP_BODY_LIMIT?.trim() || "50mb";
+  app.use(express.json({ limit: bodyLimit }));
+  app.use(express.urlencoded({ limit: bodyLimit, extended: true }));
   app.get("/health", (req, res) => {
     const instances = bridge.getInstances();
     const publicInstances = instances.map(toPublic);
@@ -1346,20 +1813,33 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
       warnedVersionMismatches.add(pluginSessionId);
       console.error(`[version-mismatch] Studio plugin v${registered.pluginVersion} (${registered.pluginVariant}) does not match MCP server v${registered.serverVersion} for ${registered.instanceId}/${registered.role}`);
     }
+    if (registered?.protocolMismatch && !warnedProtocolMismatches.has(pluginSessionId)) {
+      warnedProtocolMismatches.add(pluginSessionId);
+      console.error(`[protocol-mismatch] Studio plugin protocol v${registered.pluginProtocolVersion} does not match MCP server protocol v${registered.serverProtocolVersion} for ${registered.instanceId}/${registered.role}. Run --auto-install-plugin to update the plugin.`);
+    }
     res.json({
       success: true,
       assignedRole: result.assignedRole,
       instanceId: result.instanceId,
+      sessionToken: result.sessionToken,
+      serverEpoch: bridge.serverEpoch,
       serverVersion: serverConfig?.version,
       serverProtocolVersion: MCP_PROTOCOL_VERSION,
       versionMismatch: registered?.versionMismatch ?? false,
-      protocolMismatch: registered?.protocolMismatch ?? false
+      protocolMismatch: registered?.protocolMismatch ?? false,
+      capabilities: ["core", "scene", "mutation", "scripts", "runtime", "assets", "ui", "environment", "terrain", "build", "media", "sync", "safety"]
     });
   });
   app.post("/disconnect", (req, res) => {
     const { pluginSessionId } = req.body;
+    if (!pluginAuthorized(req, pluginSessionId)) {
+      res.status(401).json({ success: false, error: "invalid_session_token" });
+      return;
+    }
     if (pluginSessionId) {
       bridge.unregisterInstance(pluginSessionId, "plugin_request");
+      warnedVersionMismatches.delete(pluginSessionId);
+      warnedProtocolMismatches.delete(pluginSessionId);
     }
     res.json({ success: true });
   });
@@ -1372,6 +1852,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
       instances: publicInstances,
       serverVersion: serverConfig?.version,
       protocolVersion: MCP_PROTOCOL_VERSION,
+      serverEpoch: bridge.serverEpoch,
       versionMismatch: publicInstances.some((inst) => inst.versionMismatch),
       protocolMismatch: publicInstances.some((inst) => inst.protocolMismatch),
       lazyTools: isLazyTools(),
@@ -1427,6 +1908,10 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
   });
   app.get("/poll", (req, res) => {
     const pluginSessionId = req.query.pluginSessionId;
+    if (!pluginAuthorized(req, pluginSessionId)) {
+      res.status(401).json({ error: "invalid_session_token", knownInstance: false, request: null });
+      return;
+    }
     if (pluginSessionId) {
       bridge.updateInstanceActivity(pluginSessionId);
     }
@@ -1468,11 +1953,14 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
       });
       return;
     }
-    const pendingRequest = knownInstance && callerInstanceId && callerRole ? bridge.getPendingRequest(callerInstanceId, callerRole) : null;
+    const pendingRequest = knownInstance && pluginSessionId ? bridge.getPendingRequestForSession(pluginSessionId) : null;
     if (pendingRequest) {
       res.json({
         request: pendingRequest.request,
         requestId: pendingRequest.requestId,
+        serverEpoch: pendingRequest.serverEpoch,
+        deliveryAttempt: pendingRequest.deliveryAttempt,
+        leaseToken: pendingRequest.leaseToken,
         mcpConnected: true,
         pluginConnected: true,
         knownInstance,
@@ -1483,7 +1971,8 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
         protocolVersion: callerPluginProtocolVersion,
         versionMismatch,
         protocolMismatch,
-        proxyInstanceCount: proxyInstances.size
+        proxyInstanceCount: proxyInstances.size,
+        cancellations: pluginSessionId ? bridge.getCancellationEvents(pluginSessionId) : []
       });
     } else {
       res.json({
@@ -1498,16 +1987,79 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
         protocolVersion: callerPluginProtocolVersion,
         versionMismatch,
         protocolMismatch,
-        proxyInstanceCount: proxyInstances.size
+        proxyInstanceCount: proxyInstances.size,
+        cancellations: pluginSessionId ? bridge.getCancellationEvents(pluginSessionId) : []
       });
     }
   });
+  app.post("/reconcile", (req, res) => {
+    const pluginSessionId = typeof req.body?.pluginSessionId === "string" ? req.body.pluginSessionId : void 0;
+    const serverEpoch = typeof req.body?.serverEpoch === "string" ? req.body.serverEpoch : void 0;
+    const receipts = Array.isArray(req.body?.receipts) ? req.body.receipts : void 0;
+    if (!pluginAuthorized(req, pluginSessionId)) {
+      res.status(401).json({ error: "invalid_session_token" });
+      return;
+    }
+    if (!pluginSessionId || !serverEpoch || !receipts) {
+      res.status(400).json({ error: "missing_reconcile_fields" });
+      return;
+    }
+    const reconciled = bridge.reconcilePluginReceipts(pluginSessionId, serverEpoch, receipts);
+    res.json({ success: true, reconciled });
+  });
+  app.post("/ack", (req, res) => {
+    const requestId = typeof req.body?.requestId === "string" ? req.body.requestId : "";
+    const pluginSessionId = typeof req.body?.pluginSessionId === "string" ? req.body.pluginSessionId : void 0;
+    if (!pluginAuthorized(req, pluginSessionId)) {
+      res.status(401).json({ error: "invalid_session_token", requestId });
+      return;
+    }
+    const fence = {
+      serverEpoch: req.body?.serverEpoch,
+      pluginSessionId: pluginSessionId ?? "",
+      deliveryAttempt: req.body?.deliveryAttempt,
+      leaseToken: req.body?.leaseToken
+    };
+    const requiresFence = !!pluginSessionId && (bridge.getInstanceBySessionId(pluginSessionId)?.pluginProtocolVersion ?? 0) >= 3;
+    if (!requestId || !bridge.getRequestStatus(requestId)) {
+      res.status(404).json({ error: "not_found", requestId });
+      return;
+    }
+    const acknowledged = requiresFence ? bridge.acknowledgeFencedRequest(requestId, fence) : bridge.acknowledgeRequest(requestId);
+    if (!acknowledged) {
+      res.status(409).json({ error: "stale_or_unknown_delivery", requestId });
+      return;
+    }
+    res.json({ success: true, requestId });
+  });
+  app.post("/cancel", (req, res) => {
+    const requestId = typeof req.body?.requestId === "string" ? req.body.requestId : "";
+    if (!requestId || !bridge.cancelRequest(requestId)) {
+      res.status(409).json({ success: false, error: "request_not_cancellable", requestId });
+      return;
+    }
+    res.json({ success: true, requestId, state: "cancelled" });
+  });
+  app.get("/request/:requestId/status", (req, res) => {
+    const status = bridge.getRequestStatus(req.params.requestId);
+    if (!status) {
+      res.status(404).json({ error: "request_not_found", requestId: req.params.requestId });
+      return;
+    }
+    res.json(status);
+  });
   app.post("/response", (req, res) => {
-    const { requestId, response, error } = req.body;
-    if (error) {
-      bridge.rejectRequest(requestId, error);
-    } else {
-      bridge.resolveRequest(requestId, response);
+    const { requestId, response, error, pluginSessionId, serverEpoch, deliveryAttempt, leaseToken } = req.body;
+    if (!pluginAuthorized(req, pluginSessionId)) {
+      res.status(401).json({ success: false, error: "invalid_session_token", requestId });
+      return;
+    }
+    const fence = { serverEpoch, pluginSessionId, deliveryAttempt, leaseToken };
+    const requiresFence = (bridge.getInstanceBySessionId(pluginSessionId)?.pluginProtocolVersion ?? 0) >= 3;
+    const accepted = requiresFence ? error ? bridge.rejectFencedRequest(requestId, error, fence) : bridge.resolveFencedRequest(requestId, response, fence) : error ? (bridge.rejectRequest(requestId, error), true) : (bridge.resolveRequest(requestId, response), true);
+    if (!accepted) {
+      res.status(409).json({ success: false, error: "stale_or_unknown_delivery", requestId });
+      return;
     }
     res.json({ success: true });
   });
@@ -1524,7 +2076,10 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
       const response = await bridge.sendRequest(endpoint, data, targetInstanceId, targetRole);
       res.json({ response });
     } catch (err) {
-      res.status(500).json({ error: err.message || "Proxy request failed" });
+      res.status(500).json({
+        error: err.message || "Proxy request failed",
+        ...err instanceof RequestOutcomeUnknownError ? { outcome: err.outcome, requestId: err.requestId } : {}
+      });
     }
   });
   if (serverConfig) {
@@ -1555,6 +2110,12 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
           if (allowedTools && !allowedTools.has(name)) {
             throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
           }
+          const definition = legacyFilteredTools.find((tool) => tool.name === name);
+          const capabilities = clientCapabilities.get(bearerToken(req) ?? "");
+          const capability = definition ? requiredCapability(name, definition.category) : void 0;
+          if (capability && capabilities && !capabilities.has(capability)) {
+            throw new McpError(ErrorCode.InvalidRequest, `Capability required: ${capability}`);
+          }
           try {
             if (registry) {
               const registryResult = await registry.callTool(name, tools, args || {});
@@ -1686,12 +2247,12 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, registry) {
   return app;
 }
 function listenWithRetry(app, host, startPort, maxAttempts = 5) {
-  return new Promise(async (resolve6, reject) => {
+  return new Promise(async (resolve7, reject) => {
     for (let i = 0; i < maxAttempts; i++) {
       const port = startPort + i;
       try {
         const server = await bindPort(app, host, port);
-        resolve6({ server, port });
+        resolve7({ server, port });
         return;
       } catch (err) {
         if (err.code === "EADDRINUSE") {
@@ -1706,7 +2267,7 @@ function listenWithRetry(app, host, startPort, maxAttempts = 5) {
   });
 }
 function bindPort(app, host, port) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const server = http.createServer(app);
     attachBridgeWebSocket(server, app.bridge);
     const onError = (err) => {
@@ -1716,11 +2277,12 @@ function bindPort(app, host, port) {
     server.once("error", onError);
     server.listen(port, host, () => {
       server.removeListener("error", onError);
-      resolve6(server);
+      resolve7(server);
     });
   });
 }
 function attachBridgeWebSocket(server, bridge) {
+  const requirePluginAuth = process.env.NODE_ENV !== "test";
   const streams = /* @__PURE__ */ new Map();
   const wss = new WebSocketServer({ noServer: true });
   const deliver = (pluginSessionId) => {
@@ -1741,7 +2303,8 @@ function attachBridgeWebSocket(server, bridge) {
     if (url.pathname !== "/stream")
       return;
     const pluginSessionId = url.searchParams.get("pluginSessionId");
-    if (!pluginSessionId || !bridge.getInstanceBySessionId(pluginSessionId)) {
+    const sessionToken = url.searchParams.get("sessionToken") ?? void 0;
+    if (!pluginSessionId || !bridge.getInstanceBySessionId(pluginSessionId) || requirePluginAuth && !bridge.authenticatePlugin(pluginSessionId, sessionToken ?? "")) {
       socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
       socket.destroy();
       return;
@@ -1756,9 +2319,30 @@ function attachBridgeWebSocket(server, bridge) {
       bridge.updateInstanceActivity(pluginSessionId);
       try {
         const message = JSON.parse(raw.toString());
-        if (message.type !== "response" || typeof message.requestId !== "string")
+        if (typeof message.requestId !== "string")
           return;
-        if (message.error)
+        const fence = {
+          serverEpoch: message.serverEpoch,
+          pluginSessionId,
+          deliveryAttempt: message.deliveryAttempt,
+          leaseToken: message.leaseToken
+        };
+        const requiresFence = (bridge.getInstanceBySessionId(pluginSessionId)?.pluginProtocolVersion ?? 0) >= 3;
+        if (message.type === "ack") {
+          if (requiresFence)
+            bridge.acknowledgeFencedRequest(message.requestId, fence);
+          else
+            bridge.acknowledgeRequest(message.requestId);
+          return;
+        }
+        if (message.type !== "response")
+          return;
+        if (requiresFence) {
+          if (message.error)
+            bridge.rejectFencedRequest(message.requestId, message.error, fence);
+          else
+            bridge.resolveFencedRequest(message.requestId, message.response, fence);
+        } else if (message.error)
           bridge.rejectRequest(message.requestId, message.error);
         else
           bridge.resolveRequest(message.requestId, message.response);
@@ -1780,12 +2364,27 @@ var init_http_server = __esm({
     init_tool_shape();
     init_errors();
     init_structured_output();
+    init_capability_policy();
     init_server_instructions();
     init_resources();
     init_tool_catalog();
     TOOL_HANDLERS = {
       get_roblox_docs: (tools, body) => tools.getRobloxDocs(body.name, body.doc_type, body.section),
       get_session_summary: (tools) => tools.getSessionSummary(),
+      get_request_status: (tools, body) => tools.getRequestStatus(body.requestId),
+      get_transport_diagnostics: (tools) => tools.getTransportDiagnostics(),
+      cancel_request: (tools, body) => tools.cancelRequest(body.requestId),
+      detect_roblox_project: (tools, body) => tools.detectRobloxProject(body.root),
+      validate_script_source: (tools, body) => tools.validateScriptSource(body.source, body.fileName),
+      format_script_preview: (tools, body) => tools.formatScriptPreview(body.source, body.fileName),
+      resolve_instance_source_file: (tools, body) => tools.resolveInstanceSourceFile(body.instancePath, body.root),
+      run_project_tests: (tools, body) => tools.runProjectTests(body.root, body.script),
+      get_dependency_graph: (tools, body) => tools.getDependencyGraph(body.root),
+      install_wally_packages: (tools, body) => tools.installWallyPackages(body.root, body.confirm),
+      run_quality_gate: (tools, body) => tools.runQualityGate(body.root),
+      validate_with_luau_lsp: (tools, body) => tools.validateWithLuauLsp(body.root, body.files),
+      generate_rojo_sourcemap: (tools, body) => tools.generateRojoSourcemap(body.root, body.output),
+      build_rojo_project: (tools, body) => tools.buildRojoProject(body.root, body.output),
       tool_catalog_search: (tools, body) => tools.toolCatalogSearch(body),
       load_toolset: (tools, body) => tools.loadToolset(body),
       get_world_snapshot: (tools, body) => tools.getWorldSnapshot(body.path, body.level, body.topNPerClass, body.instance_id),
@@ -1793,7 +2392,7 @@ var init_http_server = __esm({
       get_changes_since: (tools, body) => tools.getChangesSince(body.snapshotId, body.path, body.instance_id),
       scene_search: (tools, body) => tools.sceneSearch(body.query, body.path, body.limit, body.instance_id),
       playtest_sample_state: (tools, body) => tools.playtestSampleState(body.domains, body.target, body.instance_id),
-      apply_mutation_plan: (tools, body) => tools.applyMutationPlan(body.operations, body.dryRun, body.confirm, body.instance_id),
+      apply_mutation_plan: (tools, body) => tools.applyMutationPlan(body.operations, body.dryRun, body.confirm, body.instance_id, body.atomic),
       list_recipes: (tools) => tools.listRecipes(),
       apply_recipe: (tools, body) => tools.applyRecipe(body.recipe, body.params, body.instance_id),
       run_gameplay_assertions: (tools, body) => tools.runGameplayAssertions(body.assertions, body.target, body.instance_id),
@@ -2179,8 +2778,8 @@ var init_safety_manager = __esm({
         }
         return { allowed, requiresConfirmation, blocked, dryRun: false, reasons, warnings, matchedPatterns };
       }
-      isProtectedPath(path8) {
-        const trimmed = path8.trim();
+      isProtectedPath(path10) {
+        const trimmed = path10.trim();
         return this.config.protectedPaths.some((p) => p === trimmed || trimmed === `game.${p}`);
       }
       recordOperation(record) {
@@ -2193,10 +2792,10 @@ var init_safety_manager = __esm({
       getHistory() {
         return [...this.history].reverse();
       }
-      backupScript(path8, source) {
-        const existing = this.backups.get(path8);
-        this.backups.set(path8, {
-          path: path8,
+      backupScript(path10, source) {
+        const existing = this.backups.get(path10);
+        this.backups.set(path10, {
+          path: path10,
           source,
           previous: existing?.source,
           timestamp: Date.now()
@@ -2207,8 +2806,8 @@ var init_safety_manager = __esm({
             this.backups.delete(oldestKey);
         }
       }
-      getBackup(path8) {
-        return this.backups.get(path8);
+      getBackup(path10) {
+        return this.backups.get(path10);
       }
       listBackups() {
         return [...this.backups.values()].sort((a, b) => b.timestamp - a.timestamp);
@@ -2689,6 +3288,7 @@ local parent = resolvePath(${luaString(parent)})
 if not parent then return { error = "Parent not found: " .. ${luaString(parent)} } end
 local existing = parent:FindFirstChild(${luaString(name)})
 if existing then existing:Destroy() end
+if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 local door = Instance.new("Part")
 door.Name = ${luaString(name)}
 door.Size = Vector3.new(8, 10, 1)
@@ -2725,6 +3325,7 @@ local group = SoundService:FindFirstChild(groupName)
 if not group then group = Instance.new("SoundGroup") group.Name = groupName group.Parent = SoundService end
 local existing = SoundService:FindFirstChild(${luaString(name)})
 if existing then existing:Destroy() end
+if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 local sound = Instance.new("Sound")
 sound.Name = ${luaString(name)}
 sound.SoundId = ${luaString(soundId)}
@@ -2745,6 +3346,7 @@ local parent = resolvePath(${luaString(parent)})
 if not parent then return { error = "Parent not found: " .. ${luaString(parent)} } end
 local existing = parent:FindFirstChild(${luaString(name)})
 if existing then existing:Destroy() end
+if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 local brick = Instance.new("Part")
 brick.Name = ${luaString(name)}
 brick.Size = Vector3.new(8, 1, 8)
@@ -3396,12 +3998,14 @@ var init_mutation = __esm({
                   property: { type: "string", description: "For set_property." },
                   name: { type: "string", description: "For set_attribute." },
                   tag: { type: "string", description: "For add_tag / remove_tag." },
-                  value: { type: ["boolean", "number", "string"], description: "For set_property / set_attribute (primitive)." }
+                  value: { type: ["boolean", "number", "string"], description: "For set_property / set_attribute (primitive)." },
+                  expected: { type: ["boolean", "number", "string", "null"], description: "Optional optimistic-lock value. The whole plan is rejected before writes when the current value differs." }
                 },
                 required: ["op", "target"]
               }
             },
             dryRun: { type: "boolean", description: "Preview the diff without applying (default false)." },
+            atomic: { type: "boolean", description: "Rollback earlier successful operations when a later operation fails (default true)." },
             confirm: { type: "boolean", description: "Approve a large plan the safety layer gates." },
             instance_id: { type: "string", description: "Connected Studio place id. Required only when multiple places are open." }
           },
@@ -3828,7 +4432,7 @@ var init_scripting = __esm({
             },
             usePattern: {
               type: "boolean",
-              description: "Use Lua pattern matching instead of literal (default: false)"
+              description: "Use Lua pattern matching instead of literal (default: false). Lua patterns do not support regex alternation; | is literal, so run separate searches for alternatives."
             },
             contextLines: {
               type: "number",
@@ -6820,6 +7424,102 @@ var init_meta = __esm({
           properties: {}
         }
       },
+      {
+        name: "get_request_status",
+        category: "read",
+        description: "Look up a bridge request after a timeout. Use the requestId from an outcome_unknown error before deciding whether a mutation is safe to retry.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            requestId: { type: "string", description: "Bridge request id from an outcome_unknown error." }
+          },
+          required: ["requestId"]
+        }
+      },
+      {
+        name: "get_transport_diagnostics",
+        category: "read",
+        description: "Return payload-free local transport metrics: queue depth, retries, BUSY/outcome_unknown/cancel/completion counts, server epoch, and latency p50/p95/p99.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "cancel_request",
+        category: "write",
+        description: "Cancel a queued bridge request before the plugin acknowledges execution. Returns false once execution has started; this never claims to stop an already-running mutation.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            requestId: { type: "string", description: "Bridge request id to cancel." }
+          },
+          required: ["requestId"]
+        }
+      },
+      {
+        name: "detect_roblox_project",
+        category: "read",
+        description: "Detect Rojo, Wally, Rokit, Selene, StyLua, and sourcemap files and report which optional quality tools are installed.",
+        inputSchema: { type: "object", properties: { root: { type: "string", description: "Project directory (defaults to the server working directory)." } } }
+      },
+      {
+        name: "validate_script_source",
+        category: "read",
+        description: "Run available luau-analyze, Selene, and StyLua checks on source without writing it to the Roblox DataModel. Missing binaries are reported explicitly.",
+        inputSchema: { type: "object", properties: { source: { type: "string" }, fileName: { type: "string" } }, required: ["source"] }
+      },
+      {
+        name: "format_script_preview",
+        category: "read",
+        description: "Return a StyLua formatting preview through stdin; user source is never formatted or written implicitly.",
+        inputSchema: { type: "object", properties: { source: { type: "string" }, fileName: { type: "string" } }, required: ["source"] }
+      },
+      {
+        name: "resolve_instance_source_file",
+        category: "read",
+        description: "Resolve an Instance path through a Rojo-style sourcemap.json when one is present.",
+        inputSchema: { type: "object", properties: { instancePath: { type: "string" }, root: { type: "string" } }, required: ["instancePath"] }
+      },
+      {
+        name: "run_project_tests",
+        category: "write",
+        description: "Run an explicitly selected Lune project test script; no test script is guessed.",
+        inputSchema: { type: "object", properties: { root: { type: "string" }, script: { type: "string" } }, required: ["script"] }
+      },
+      {
+        name: "get_dependency_graph",
+        category: "read",
+        description: "Read Wally manifest/lockfile metadata into a compact dependency list without installing packages.",
+        inputSchema: { type: "object", properties: { root: { type: "string" } } }
+      },
+      {
+        name: "install_wally_packages",
+        category: "write",
+        description: "Run wally install in the detected project only after explicit confirm=true.",
+        inputSchema: { type: "object", properties: { root: { type: "string" }, confirm: { type: "boolean" } }, required: ["confirm"] }
+      },
+      {
+        name: "run_quality_gate",
+        category: "read",
+        description: "Run available Rojo sourcemap, Selene, StyLua, and luau-lsp project checks and return structured per-tool results.",
+        inputSchema: { type: "object", properties: { root: { type: "string" } } }
+      },
+      {
+        name: "validate_with_luau_lsp",
+        category: "read",
+        description: "Run luau-lsp analyze against selected files, automatically using the detected Rojo sourcemap when present.",
+        inputSchema: { type: "object", properties: { root: { type: "string" }, files: { type: "array", items: { type: "string" } } } }
+      },
+      {
+        name: "generate_rojo_sourcemap",
+        category: "write",
+        description: "Generate a Rojo sourcemap from the detected project file into an explicit output path.",
+        inputSchema: { type: "object", properties: { root: { type: "string" }, output: { type: "string" } } }
+      },
+      {
+        name: "build_rojo_project",
+        category: "write",
+        description: "Build the detected Rojo project to an explicit RBXL/RBXM output path.",
+        inputSchema: { type: "object", properties: { root: { type: "string" }, output: { type: "string" } }, required: ["output"] }
+      },
       {
         name: "load_toolset",
         category: "read",
@@ -7349,8 +8049,8 @@ for _, p in ipairs(paths) do
 end
 return { nodes = out, count = #out }`;
 }
-function buildWorldSnapshotLuau(path8 = "game", level = "overview", topNPerClass = 12) {
-  const safePath = luaString(path8);
+function buildWorldSnapshotLuau(path10 = "game", level = "overview", topNPerClass = 12) {
+  const safePath = luaString(path10);
   const safeTopN = luaNumber(Math.max(1, Math.floor(topNPerClass)));
   return `${PATH_RESOLVER_LUA}
 local root = resolvePath(${safePath})
@@ -7362,6 +8062,8 @@ local soundCount, soundPlaying, soundLooped = 0, 0, 0
 local scriptCount, localScriptCount, moduleCount = 0, 0, 0
 local taggedCount = 0
 for _, d in ipairs(root:GetDescendants()) do
+		if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
+	if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 	total = total + 1
 	byClass[d.ClassName] = (byClass[d.ClassName] or 0) + 1
 	if d:IsA("Sound") then
@@ -7458,8 +8160,8 @@ end`;
 });
 
 // ../core/dist/builders/scene-search.js
-function buildSceneSearchLuau(query, path8 = "game", limit = 10) {
-  const safePath = luaString(path8);
+function buildSceneSearchLuau(query, path10 = "game", limit = 10) {
+  const safePath = luaString(path10);
   const safeQuery = luaString(query.toLowerCase());
   const safeLimit = luaNumber(Math.max(1, Math.min(50, Math.floor(limit))));
   return `${PATH_RESOLVER_LUA}
@@ -7479,6 +8181,8 @@ end
 
 local scored = {}
 for _, d in ipairs(root:GetDescendants()) do
+		if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
+	if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 	local name = lc(d.Name)
 	local class = lc(d.ClassName)
 	local parentName = d.Parent and lc(d.Parent.Name) or ""
@@ -7525,8 +8229,8 @@ var init_scene_search = __esm({
 });
 
 // ../core/dist/builders/world-fingerprint.js
-function buildWorldFingerprintLuau(path8 = "game", maxNodes = 8e3) {
-  const safePath = luaString(path8);
+function buildWorldFingerprintLuau(path10 = "game", maxNodes = 8e3) {
+  const safePath = luaString(path10);
   const safeMax = luaNumber(Math.max(1, Math.floor(maxNodes)));
   return `${PATH_RESOLVER_LUA}
 ${FINGERPRINT_HELPERS_LUA}
@@ -7536,6 +8240,8 @@ local fp = {}
 local count = 0
 local truncated = false
 for _, d in ipairs(root:GetDescendants()) do
+		if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
+	if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 	if count >= ${safeMax} then truncated = true break end
 	local id = nid(d)
 	fp[id] = {
@@ -7701,9 +8407,9 @@ var init_world_changes = __esm({
         this.seq += 1;
         return `snap_${Date.now().toString(36)}_${this.seq}`;
       }
-      put(path8, fingerprint) {
+      put(path10, fingerprint) {
         const id = this.newId();
-        this.snapshots.set(id, { id, path: path8, fingerprint, createdAt: Date.now() });
+        this.snapshots.set(id, { id, path: path10, fingerprint, createdAt: Date.now() });
         this.prune();
         return id;
       }
@@ -8697,8 +9403,8 @@ function crc32(buf) {
     crc = CRC_TABLE[(crc ^ buf[i]) & 255] ^ crc >>> 8;
   return (crc ^ 4294967295) >>> 0;
 }
-function writeChunk(type, data) {
-  const typeBytes = Buffer.from(type, "ascii");
+function writeChunk(type2, data) {
+  const typeBytes = Buffer.from(type2, "ascii");
   const length = Buffer.alloc(4);
   length.writeUInt32BE(data.length);
   const crcInput = Buffer.concat([typeBytes, data]);
@@ -8763,7 +9469,7 @@ function encodeImageFromRgbaResponse(response, format, quality) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -9199,18 +9905,18 @@ var init_world_model_tools = __esm({
       constructor(runtime) {
         this.runtime = runtime;
       }
-      async getWorldSnapshot(path8, level, topNPerClass, instance_id) {
-        const code = buildWorldSnapshotLuau(path8 ?? "game", level ?? "overview", topNPerClass ?? 12);
+      async getWorldSnapshot(path10, level, topNPerClass, instance_id) {
+        const code = buildWorldSnapshotLuau(path10 ?? "game", level ?? "overview", topNPerClass ?? 12);
         const response = await this.runtime.callSingle("/api/execute-luau", { code }, "edit", instance_id);
         return wrapToolJsonText(normalizeExecuteLuauToolResult(response, {
           error: "get_world_snapshot returned non-object execute-luau output"
         }));
       }
-      async sceneSearch(query, path8, limit, instance_id) {
+      async sceneSearch(query, path10, limit, instance_id) {
         if (!query || !query.trim()) {
           throw new Error("query is required for scene_search");
         }
-        const response = await this.runtime.callSingle("/api/execute-luau", { code: buildSceneSearchLuau(query, path8 ?? "game", limit ?? 10) }, "edit", instance_id);
+        const response = await this.runtime.callSingle("/api/execute-luau", { code: buildSceneSearchLuau(query, path10 ?? "game", limit ?? 10) }, "edit", instance_id);
         return wrapToolJsonText(normalizeExecuteLuauToolResult(response, {
           query,
           total: 0,
@@ -9230,8 +9936,8 @@ var init_world_model_tools = __esm({
           error: "get_node_batch returned non-object execute-luau output"
         }));
       }
-      async _captureFingerprint(path8, instance_id) {
-        const response = await this.runtime.callSingle("/api/execute-luau", { code: buildWorldFingerprintLuau(path8) }, "edit", instance_id);
+      async _captureFingerprint(path10, instance_id) {
+        const response = await this.runtime.callSingle("/api/execute-luau", { code: buildWorldFingerprintLuau(path10) }, "edit", instance_id);
         try {
           const rv = response?.returnValue;
           if (typeof rv === "string") {
@@ -9244,8 +9950,8 @@ var init_world_model_tools = __esm({
         }
         return { fp: {}, count: 0, truncated: false, error: "Could not parse world fingerprint" };
       }
-      async getChangesSince(snapshotId, path8, instance_id) {
-        const p = path8 ?? "game";
+      async getChangesSince(snapshotId, path10, instance_id) {
+        const p = path10 ?? "game";
         const cur = await this._captureFingerprint(p, instance_id);
         const wrap4 = (obj) => ({ content: [{ type: "text", text: JSON.stringify(obj) }] });
         if (cur.error)
@@ -9409,8 +10115,8 @@ var init_response_shape = __esm({
 });
 
 // ../core/dist/builders/scene-summary.js
-function buildSceneSummaryLuau(path8 = "game.Workspace", topN = 20) {
-  const safePath = luaString(path8);
+function buildSceneSummaryLuau(path10 = "game.Workspace", topN = 20) {
+  const safePath = luaString(path10);
   const safeTopN = luaNumber(Math.max(1, Math.floor(topN)));
   return `${PATH_RESOLVER_LUA}
 local root = resolvePath(${safePath})
@@ -9459,8 +10165,8 @@ var init_scene_read_tools = __esm({
       constructor(runtime) {
         this.runtime = runtime;
       }
-      async getFileTree(path8 = "", instance_id) {
-        const response = await this.runtime.callSingle("/api/file-tree", { path: path8 }, void 0, instance_id);
+      async getFileTree(path10 = "", instance_id) {
+        const response = await this.runtime.callSingle("/api/file-tree", { path: path10 }, void 0, instance_id);
         return compactText(response);
       }
       async getPlaceInfo(instance_id) {
@@ -9514,9 +10220,9 @@ var init_scene_read_tools = __esm({
         const response = await this.runtime.callSingle("/api/class-info", { className }, void 0, instance_id);
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
-      async getProjectStructure(path8, maxDepth, scriptsOnly, instance_id) {
+      async getProjectStructure(path10, maxDepth, scriptsOnly, instance_id) {
         const response = await this.runtime.callSingle("/api/project-structure", {
-          path: path8,
+          path: path10,
           maxDepth,
           scriptsOnly
         }, void 0, instance_id);
@@ -9812,13 +10518,14 @@ ${JSON.stringify({ errors: result.errors, warnings: result.warnings })}`
 });
 
 // ../core/dist/builders/mutation-plan.js
-function buildMutationPlanLuau(operations, dryRun) {
+function buildMutationPlanLuau(operations, dryRun, atomic = true) {
   const opsJson = JSON.stringify(JSON.stringify(operations));
   return `${PATH_RESOLVER_LUA}
 local HttpService = game:GetService("HttpService")
 local CollectionService = game:GetService("CollectionService")
 local ops = HttpService:JSONDecode(${opsJson})
 local dryRun = ${luaBool(dryRun)}
+local atomic = ${luaBool(atomic)}
 
 local function ser(v)
 	local t = typeof(v)
@@ -9829,8 +10536,26 @@ end
 local results = {}
 local rollback = {}
 local succeeded, failed = 0, 0
+local conflicts = {}
+
+for index, op in ipairs(ops) do
+	if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { applied = false, cancelled = true } end
+	if op.expected ~= nil then
+		local inst = resolvePath(op.target)
+		local current
+		if inst and op.op == "set_property" then current = ser(inst[op.property])
+		elseif inst and op.op == "set_attribute" then current = ser(inst:GetAttribute(op.name))
+		elseif inst and (op.op == "add_tag" or op.op == "remove_tag") then current = CollectionService:HasTag(inst, op.tag) end
+		if current ~= op.expected then table.insert(conflicts, { index = index, target = op.target, expected = op.expected, actual = current }) end
+	end
+end
+
+if #conflicts > 0 then
+	return { applied = false, conflict = true, conflicts = conflicts, results = {}, rollback = {}, summary = { total = #ops, succeeded = 0, failed = 0 } }
+end
 
 for _, op in ipairs(ops) do
+	if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { applied = false, cancelled = true, rollback = rollback } end
 	local r = { op = op.op, target = op.target }
 	local inst = resolvePath(op.target)
 	if not inst then
@@ -9887,9 +10612,26 @@ for _, op in ipairs(ops) do
 	table.insert(results, r)
 end
 
+local rolledBack = false
+if atomic and not dryRun and failed > 0 then
+	rolledBack = true
+	for i = #rollback, 1, -1 do
+		local op = rollback[i]
+		local inst = resolvePath(op.target)
+		if inst then pcall(function()
+			if op.op == "set_property" then inst[op.property] = op.value
+			elseif op.op == "set_attribute" then inst:SetAttribute(op.name, op.value)
+			elseif op.op == "add_tag" then CollectionService:AddTag(inst, op.tag)
+			elseif op.op == "remove_tag" then CollectionService:RemoveTag(inst, op.tag) end
+		end) end
+	end
+end
+
 return {
-	applied = not dryRun,
+	applied = not dryRun and not rolledBack,
 	dryRun = dryRun,
+	atomic = atomic,
+	rolledBack = rolledBack,
 	results = results,
 	rollback = rollback,
 	summary = { total = #ops, succeeded = succeeded, failed = failed },
@@ -10051,7 +10793,7 @@ var init_mutation_tools = __esm({
       }
       // Transactional batch mutations: apply many small edits in one round-trip with a
       // dry-run diff and a ready-to-run reverse plan in the receipt (stateless rollback).
-      async applyMutationPlan(operations, dryRun, confirm, instance_id) {
+      async applyMutationPlan(operations, dryRun, confirm, instance_id, atomic = true) {
         if (!Array.isArray(operations) || operations.length === 0) {
           throw new Error("operations (a non-empty array) is required for apply_mutation_plan");
         }
@@ -10060,7 +10802,7 @@ var init_mutation_tools = __esm({
           if (gated)
             return gated;
         }
-        const response = await this.runtime.callSingle("/api/execute-luau", { code: buildMutationPlanLuau(operations, !!dryRun) }, "edit", instance_id);
+        const response = await this.runtime.callSingle("/api/execute-luau", { code: buildMutationPlanLuau(operations, !!dryRun, atomic) }, "edit", instance_id);
         if (!dryRun)
           this.runtime.recordOperation("bulk_mutate", `mutation plan: ${operations.length} ops`);
         return wrapToolJsonText(normalizeExecuteLuauToolResult(response, {
@@ -10570,9 +11312,9 @@ var init_image_client = __esm({
 });
 
 // ../core/dist/tools/asset-tools.js
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
 var AssetTools;
 var init_asset_tools = __esm({
   "../core/dist/tools/asset-tools.js"() {
@@ -10588,13 +11330,13 @@ var init_asset_tools = __esm({
       }
       // ─── Static helpers (library path) ────────────────────────────────
       static findProjectRoot(startDir) {
-        let dir = path.resolve(startDir);
+        let dir = path2.resolve(startDir);
         let previous = "";
         while (dir !== previous) {
-          if (fs.existsSync(path.join(dir, ".git")) || fs.existsSync(path.join(dir, "package.json")))
+          if (fs2.existsSync(path2.join(dir, ".git")) || fs2.existsSync(path2.join(dir, "package.json")))
             return dir;
           previous = dir;
-          dir = path.dirname(dir);
+          dir = path2.dirname(dir);
         }
         return null;
       }
@@ -10602,22 +11344,22 @@ var init_asset_tools = __esm({
         if (!candidate)
           return false;
         try {
-          return fs.statSync(candidate).isDirectory();
+          return fs2.statSync(candidate).isDirectory();
         } catch {
           return false;
         }
       }
       static ensureWritableDirectory(candidate, label) {
-        const resolved = path.resolve(candidate);
+        const resolved = path2.resolve(candidate);
         try {
-          fs.mkdirSync(resolved, { recursive: true });
+          fs2.mkdirSync(resolved, { recursive: true });
         } catch (error) {
           throw new Error(`Unable to create ${label} build-library directory at ${resolved}: ${error.message}`);
         }
         if (!_AssetTools.isDirectory(resolved))
           throw new Error(`${label} build-library path is not a directory: ${resolved}`);
         try {
-          fs.accessSync(resolved, fs.constants.W_OK);
+          fs2.accessSync(resolved, fs2.constants.W_OK);
         } catch (error) {
           throw new Error(`${label} build-library directory is not writable: ${resolved}. ${error.message}`);
         }
@@ -10627,26 +11369,28 @@ var init_asset_tools = __esm({
       static findLibraryPath() {
         if (_AssetTools._cachedLibraryPath)
           return _AssetTools._cachedLibraryPath;
-        const overridePath = process.env.ROBLOXSTUDIO_MCP_BUILD_LIBRARY || process.env.BUILD_LIBRARY_PATH;
-        const cwd = path.resolve(process.cwd());
+        const overridePath = process.env.BLOXFORGE_BUILD_LIBRARY || process.env.ROBLOXSTUDIO_MCP_BUILD_LIBRARY || process.env.BUILD_LIBRARY_PATH;
+        const cwd = path2.resolve(process.cwd());
         const projectRoot = _AssetTools.findProjectRoot(cwd);
-        const homeLibraryPath = path.join(os.homedir(), ".robloxstudio-mcp", "build-library");
-        const projectLibraryPath = projectRoot ? path.join(projectRoot, "build-library") : null;
-        const cwdLibraryPath = path.join(cwd, "build-library");
+        const newHomeLibraryPath = path2.join(os2.homedir(), ".bloxforge", "build-library");
+        const legacyHomeLibraryPath = path2.join(os2.homedir(), ".robloxstudio-mcp", "build-library");
+        const homeLibraryPath = fs2.existsSync(newHomeLibraryPath) ? newHomeLibraryPath : fs2.existsSync(legacyHomeLibraryPath) ? legacyHomeLibraryPath : newHomeLibraryPath;
+        const projectLibraryPath = projectRoot ? path2.join(projectRoot, "build-library") : null;
+        const cwdLibraryPath = path2.join(cwd, "build-library");
         let result;
         if (overridePath) {
           result = _AssetTools.ensureWritableDirectory(overridePath, "override");
         } else {
           const existing = [projectLibraryPath, cwdLibraryPath].find((c) => c && _AssetTools.isDirectory(c) && (() => {
             try {
-              fs.accessSync(c, fs.constants.W_OK);
+              fs2.accessSync(c, fs2.constants.W_OK);
               return true;
             } catch {
               return false;
             }
           })());
           if (existing) {
-            result = path.resolve(existing);
+            result = path2.resolve(existing);
           } else if (projectLibraryPath) {
             try {
               result = _AssetTools.ensureWritableDirectory(projectLibraryPath, "project-root");
@@ -10767,11 +11511,11 @@ var init_asset_tools = __esm({
         if (response && response.success && response.buildData) {
           const buildData = response.buildData;
           const buildId = buildData.id || `${style}/exported`;
-          const filePath = path.join(_AssetTools.findLibraryPath(), `${buildId}.json`);
-          const dirPath = path.dirname(filePath);
-          if (!fs.existsSync(dirPath))
-            fs.mkdirSync(dirPath, { recursive: true });
-          fs.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
+          const filePath = path2.join(_AssetTools.findLibraryPath(), `${buildId}.json`);
+          const dirPath = path2.dirname(filePath);
+          if (!fs2.existsSync(dirPath))
+            fs2.mkdirSync(dirPath, { recursive: true });
+          fs2.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
           response.savedTo = filePath;
         }
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
@@ -10783,11 +11527,11 @@ var init_asset_tools = __esm({
         const normalizedParts = this.normalizeBuildParts(parts, new Set(Object.keys(normalizedPalette)));
         const computedBounds = bounds || this.computeBounds(normalizedParts);
         const buildData = { id, style, bounds: computedBounds, palette: normalizedPalette, parts: normalizedParts };
-        const filePath = path.join(_AssetTools.findLibraryPath(), `${id}.json`);
-        const dirPath = path.dirname(filePath);
-        if (!fs.existsSync(dirPath))
-          fs.mkdirSync(dirPath, { recursive: true });
-        fs.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
+        const filePath = path2.join(_AssetTools.findLibraryPath(), `${id}.json`);
+        const dirPath = path2.dirname(filePath);
+        if (!fs2.existsSync(dirPath))
+          fs2.mkdirSync(dirPath, { recursive: true });
+        fs2.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
         return {
           content: [{ type: "text", text: JSON.stringify({
             success: true,
@@ -10812,11 +11556,11 @@ var init_asset_tools = __esm({
         const buildData = { id, style, bounds: result.bounds, palette, parts: result.parts, generatorCode: code };
         if (seed !== void 0)
           buildData.generatorSeed = seed;
-        const filePath = path.join(_AssetTools.findLibraryPath(), `${id}.json`);
-        const dirPath = path.dirname(filePath);
-        if (!fs.existsSync(dirPath))
-          fs.mkdirSync(dirPath, { recursive: true });
-        fs.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
+        const filePath = path2.join(_AssetTools.findLibraryPath(), `${id}.json`);
+        const dirPath = path2.dirname(filePath);
+        if (!fs2.existsSync(dirPath))
+          fs2.mkdirSync(dirPath, { recursive: true });
+        fs2.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
         return {
           content: [{ type: "text", text: JSON.stringify({
             success: true,
@@ -10830,11 +11574,11 @@ var init_asset_tools = __esm({
       }
       async importBuild(buildData, targetPath, position, instance_id) {
         if (typeof buildData === "string") {
-          const filePath = path.join(_AssetTools.findLibraryPath(), `${buildData}.json`);
-          if (!fs.existsSync(filePath)) {
+          const filePath = path2.join(_AssetTools.findLibraryPath(), `${buildData}.json`);
+          if (!fs2.existsSync(filePath)) {
             return toolErrorResult(`Build not found in library: ${buildData}`);
           }
-          buildData = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+          buildData = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
         }
         const response = await this.runtime.callSingle("/api/import-build", {
           buildData,
@@ -10846,14 +11590,14 @@ var init_asset_tools = __esm({
       async listLibrary(style) {
         const libPath = _AssetTools.findLibraryPath();
         let entries = [];
-        if (fs.existsSync(libPath)) {
+        if (fs2.existsSync(libPath)) {
           const readDir = (dir) => {
-            for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
               if (entry.isDirectory()) {
-                readDir(path.join(dir, entry.name));
+                readDir(path2.join(dir, entry.name));
               } else if (entry.name.endsWith(".json")) {
                 try {
-                  const data = JSON.parse(fs.readFileSync(path.join(dir, entry.name), "utf-8"));
+                  const data = JSON.parse(fs2.readFileSync(path2.join(dir, entry.name), "utf-8"));
                   if (style && data.style !== style)
                     continue;
                   entries.push({
@@ -10878,10 +11622,10 @@ var init_asset_tools = __esm({
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
       async getBuild(id) {
-        const filePath = path.join(_AssetTools.findLibraryPath(), `${id}.json`);
-        if (!fs.existsSync(filePath))
+        const filePath = path2.join(_AssetTools.findLibraryPath(), `${id}.json`);
+        if (!fs2.existsSync(filePath))
           return toolErrorResult(`Build not found in library: ${id}`);
-        const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        const data = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
         return { content: [{ type: "text", text: JSON.stringify(data) }] };
       }
       async importScene(sceneData, targetPath, instance_id) {
@@ -10925,10 +11669,10 @@ var init_asset_tools = __esm({
             const buildId = models[modelKey];
             if (!buildId)
               throw new Error(`Unknown model key "${modelKey}" in scene placement`);
-            const filePath = path.join(_AssetTools.findLibraryPath(), `${buildId}.json`);
-            if (!fs.existsSync(filePath))
+            const filePath = path2.join(_AssetTools.findLibraryPath(), `${buildId}.json`);
+            if (!fs2.existsSync(filePath))
               throw new Error(`Build "${buildId}" not found in library`);
-            const buildData = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            const buildData = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
             await this.runtime.callSingle("/api/import-build", {
               buildData,
               targetPath: targetPath || "Workspace",
@@ -11094,10 +11838,10 @@ var init_asset_tools = __esm({
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
       async uploadAsset(filePath, assetType, displayName, description, userId, groupId) {
-        if (!fs.existsSync(filePath))
+        if (!fs2.existsSync(filePath))
           throw new Error(`File not found: ${filePath}`);
-        const fileContent = fs.readFileSync(filePath);
-        const fileName = path.basename(filePath);
+        const fileContent = fs2.readFileSync(filePath);
+        const fileName = path2.basename(filePath);
         const cc = this.runtime.cookieClient;
         const oc = this.runtime.openCloudClient;
         if (assetType === "Decal" && cc.hasCookie()) {
@@ -11146,10 +11890,10 @@ var init_asset_tools = __esm({
         if (!response.base64)
           return toolErrorResult("plugin returned no base64 payload");
         const bytes = Buffer.from(response.base64, "base64");
-        const resolved = path.resolve(outputPath);
+        const resolved = path2.resolve(outputPath);
         try {
-          fs.mkdirSync(path.dirname(resolved), { recursive: true });
-          fs.writeFileSync(resolved, bytes);
+          fs2.mkdirSync(path2.dirname(resolved), { recursive: true });
+          fs2.writeFileSync(resolved, bytes);
         } catch (err) {
           return toolErrorResult(`failed to write ${resolved}: ${err.message}`);
         }
@@ -11173,9 +11917,9 @@ var init_asset_tools = __esm({
         let bytes;
         let sourceLabel;
         if (source.path !== void 0) {
-          const resolved = path.resolve(source.path);
+          const resolved = path2.resolve(source.path);
           try {
-            bytes = fs.readFileSync(resolved);
+            bytes = fs2.readFileSync(resolved);
           } catch (err) {
             return toolErrorResult(`failed to read ${resolved}: ${err.message}`);
           }
@@ -11227,10 +11971,10 @@ var init_asset_tools = __esm({
         const { buffer, contentType } = await this.runtime.imageClient.generate(prompt, options ?? {});
         const ext = contentType.includes("png") ? "png" : "jpg";
         const slug = prompt.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "image";
-        const dir = path.resolve(process.env.ROBLOX_IMAGE_DIR ?? path.join(process.cwd(), "generated-images"));
-        fs.mkdirSync(dir, { recursive: true });
-        const file = path.join(dir, `${slug}-${Date.now()}.${ext}`);
-        fs.writeFileSync(file, buffer);
+        const dir = path2.resolve(process.env.ROBLOX_IMAGE_DIR ?? path2.join(process.cwd(), "generated-images"));
+        fs2.mkdirSync(dir, { recursive: true });
+        const file = path2.join(dir, `${slug}-${Date.now()}.${ext}`);
+        fs2.writeFileSync(file, buffer);
         return { file, bytes: buffer.length, model: options?.model ?? DEFAULT_IMAGE_MODEL };
       }
       async imageGenerate(prompt, options) {
@@ -11740,8 +12484,8 @@ var init_episode_reasoning = __esm({
 });
 
 // ../core/dist/tools/runtime-tools.js
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 function isEndTestAlreadyCalledError(value) {
   return /EndTest.*can only be called once|can only be called once/i.test(errorMessage(value));
 }
@@ -12626,9 +13370,9 @@ var init_runtime_tools = __esm({
           const rawJson = mutable.raw_json;
           if (typeof rawJson === "string") {
             if (typeof outputPath === "string" && outputPath !== "") {
-              const resolvedOutputPath = path2.resolve(outputPath);
-              fs2.mkdirSync(path2.dirname(resolvedOutputPath), { recursive: true });
-              fs2.writeFileSync(resolvedOutputPath, rawJson, "utf8");
+              const resolvedOutputPath = path3.resolve(outputPath);
+              fs3.mkdirSync(path3.dirname(resolvedOutputPath), { recursive: true });
+              fs3.writeFileSync(resolvedOutputPath, rawJson, "utf8");
               mutable.output_path = resolvedOutputPath;
             }
             delete mutable.raw_json;
@@ -13341,6 +14085,7 @@ function buildCreateSoundLuau(options) {
   const lines = [
     `local parent = resolvePath(${luaString(options.parentPath)})`,
     `if parent == nil then error("Parent not found: " .. ${luaString(options.parentPath)}) end`,
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `local sound = Instance.new("Sound")`,
     `sound.SoundId = ${luaString(assetUri(options.soundId))}`
   ];
@@ -13361,6 +14106,7 @@ function buildCreateSoundLuau(options) {
 function buildPlaySoundLuau(options) {
   const body = `local sound = resolvePath(${luaString(options.path)})
 if sound == nil or not sound:IsA("Sound") then error("Sound not found: " .. ${luaString(options.path)}) end
+if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 sound:Play()
 return { path = sound:GetFullName(), playing = true, success = true }`;
   return wrap(body);
@@ -13369,6 +14115,7 @@ function buildCreateAnimationLuau(options) {
   const lines = [
     `local parent = resolvePath(${luaString(options.parentPath)})`,
     `if parent == nil then error("Parent not found: " .. ${luaString(options.parentPath)}) end`,
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `local anim = Instance.new("Animation")`,
     `anim.AnimationId = ${luaString(assetUri(options.animationId))}`,
     `anim.Name = ${luaString(options.name ?? "Animation")}`,
@@ -13387,6 +14134,7 @@ if animator == nil then
 	animator = Instance.new("Animator")
 	animator.Parent = controller
 end
+if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 local anim = Instance.new("Animation")
 anim.AnimationId = ${luaString(assetUri(options.animationId))}
 local track = animator:LoadAnimation(anim)
@@ -13400,6 +14148,7 @@ function buildApplyTextureLuau(options) {
   if (options.property) {
     const body2 = `local target = resolvePath(${luaString(options.targetPath)})
 if target == nil then error("Target not found: " .. ${luaString(options.targetPath)}) end
+if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 target.${options.property.replace(/[^A-Za-z0-9]/g, "")} = ${uri}
 return { path = target:GetFullName(), property = ${luaString(options.property)}, success = true }`;
     return wrap(body2);
@@ -13407,6 +14156,7 @@ return { path = target:GetFullName(), property = ${luaString(options.property)},
   const body = `local target = resolvePath(${luaString(options.targetPath)})
 if target == nil then error("Target not found: " .. ${luaString(options.targetPath)}) end
 local uri = ${uri}
+if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 local prop
 if target:IsA("ImageLabel") or target:IsA("ImageButton") then
 	prop = "Image"
@@ -13446,6 +14196,7 @@ local parent = resolvePath(${luaString(parentPath)})
 if parent == nil then error("Parent not found: " .. ${luaString(parentPath)}) end
 local inputs = { ${inputs.join(", ")} }
 local schema = ${schemaLua}
+if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 local model, meta = GenerationService:GenerateModelAsync(inputs, schema)
 if model == nil then error("GenerateModelAsync returned no model") end
 local desiredName = ${nameLua}
@@ -13510,6 +14261,7 @@ local function ensureCorner(o)
 	end
 end
 for _, o in ipairs(root:GetDescendants()) do
+	if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 	if o:IsA("GuiButton") then
 		o.BackgroundColor3 = PRIMARY
 		o.BorderSizePixel = 0
@@ -13590,6 +14342,7 @@ end
 local function lintRoot(root)
 	local interactives = {}
 	for _, o in ipairs(root:GetDescendants()) do
+		if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 		if o:IsA("GuiObject") then
 			if (o:IsA("TextLabel") or o:IsA("TextButton") or o:IsA("TextBox")) and not o.TextScaled and o.TextSize < MIN_TEXT_SIZE then
 				add("tiny_text", "warn", o, string.format("TextSize %d < %d; hard to read \u2014 raise it or use TextScaled + UITextSizeConstraint", o.TextSize, MIN_TEXT_SIZE))
@@ -13724,6 +14477,7 @@ function buildScreenGuiLuau(options) {
   const parentPath = options.parentPath ?? "StarterGui";
   const lines = [
     `local parent = resolvePath(${luaString(parentPath)}) or game:GetService("StarterGui")`,
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `local obj = Instance.new("ScreenGui")`,
     `obj.Name = ${luaString(options.name)}`
   ];
@@ -13741,6 +14495,7 @@ function buildGuiObjectLuau(className, options) {
   const lines = [
     `local parent = resolvePath(${luaString(options.parentPath)})`,
     `if parent == nil then error("Parent not found: " .. ${luaString(options.parentPath)}) end`,
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `local obj = Instance.new(${luaString(className)})`
   ];
   if (options.name !== void 0)
@@ -13783,6 +14538,7 @@ function buildApplyLayoutLuau(targetPath, options) {
     `local target = resolvePath(${luaString(targetPath)})`,
     `if target == nil then error("Target not found: " .. ${luaString(targetPath)}) end`
   ];
+  lines.push("if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end");
   if (options.layout === "grid") {
     lines.push(`local layout = Instance.new("UIGridLayout")`);
     if (options.cellSize)
@@ -13816,6 +14572,7 @@ local function ensureScale(gui)
 		scale.Parent = gui
 	end
 end
+if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 local descendants = target:GetDescendants()
 table.insert(descendants, target)
 for _, child in ipairs(descendants) do
@@ -13848,7 +14605,10 @@ function clampClock(hour) {
   return Math.max(0, Math.min(24, hour));
 }
 function buildSetTimeOfDayLuau(time) {
-  const lines = ['local Lighting = game:GetService("Lighting")'];
+  const lines = [
+    'local Lighting = game:GetService("Lighting")',
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end"
+  ];
   if (typeof time === "number") {
     lines.push(`Lighting.ClockTime = ${luaNumber(clampClock(time))}`);
   } else {
@@ -13898,6 +14658,7 @@ function buildLightingPresetLuau(preset, withPostFx = false) {
   }
   const lines = [
     'local Lighting = game:GetService("Lighting")',
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `Lighting.ClockTime = ${luaNumber(config.clockTime)}`,
     `Lighting.Ambient = ${color3FromRGB(...config.ambient)}`,
     `Lighting.OutdoorAmbient = ${color3FromRGB(...config.outdoorAmbient)}`,
@@ -13919,7 +14680,10 @@ function buildLightingPresetLuau(preset, withPostFx = false) {
   return lines.join("\n");
 }
 function buildAtmosphereLuau(options) {
-  const lines = ['local Lighting = game:GetService("Lighting")'];
+  const lines = [
+    'local Lighting = game:GetService("Lighting")',
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end"
+  ];
   lines.push(...atmosphereLines("Lighting", options));
   lines.push("return { success = true }");
   return lines.join("\n");
@@ -13927,6 +14691,7 @@ function buildAtmosphereLuau(options) {
 function buildSkyLuau(options) {
   const lines = [
     'local Lighting = game:GetService("Lighting")',
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     'local sky = Lighting:FindFirstChildOfClass("Sky") or Instance.new("Sky")'
   ];
   if (options.sunTextureId !== void 0)
@@ -13960,6 +14725,7 @@ RunService.Heartbeat:Connect(function(dt)
 end)`;
   const lines = [
     'local ServerScriptService = game:GetService("ServerScriptService")',
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `local existing = ServerScriptService:FindFirstChild(${luaString(scriptName)})`,
     "if existing then existing:Destroy() end",
     'local script = Instance.new("Script")',
@@ -14072,6 +14838,7 @@ function buildBaseplateLuau(options) {
   const mat = material(options.material ?? "Grass");
   return [
     "local Terrain = workspace.Terrain",
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `Terrain:FillBlock(CFrame.new(${vector3(...pos)}), ${vector3(...options.size)}, ${mat})`,
     `return { shape = "baseplate", volume = ${luaNumber(boxVolume(options.size))}, success = true }`
   ].join("\n");
@@ -14080,6 +14847,7 @@ function buildIslandLuau(options) {
   const mat = material(options.material ?? "Sand");
   const lines = [
     "local Terrain = workspace.Terrain",
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `Terrain:FillBall(${vector3(...options.center)}, ${luaNumber(options.radius)}, ${mat})`
   ];
   if (options.waterMaterial || options.waterRadius) {
@@ -14104,7 +14872,9 @@ function buildMountainsLuau(options) {
     `local maxHeight = ${luaNumber(options.maxHeight)}`,
     `local seed = ${luaNumber(seed)}`,
     `local baseX, baseY, baseZ = ${luaNumber(cx - ex / 2)}, ${luaNumber(cy)}, ${luaNumber(cz - ez / 2)}`,
-    `for gx = 0, ${luaNumber(ex)}, res do`,
+    `for gx = 0, ${luaNumber(ex)}, res do
+	if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end`,
+    "	if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `	for gz = 0, ${luaNumber(ez)}, res do`,
     "		local wx = baseX + gx",
     "		local wz = baseZ + gz",
@@ -14120,6 +14890,7 @@ function buildWaterLuau(options) {
   const pos = options.position ?? [0, 0, 0];
   return [
     "local Terrain = workspace.Terrain",
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `Terrain:FillBlock(CFrame.new(${vector3(...pos)}), ${vector3(...options.size)}, Enum.Material.Water)`,
     `return { shape = "water", volume = ${luaNumber(boxVolume(options.size))}, success = true }`
   ].join("\n");
@@ -14130,6 +14901,7 @@ function buildPaintMaterialLuau(options) {
   const op = options.replaceMaterial ? `Terrain:ReplaceMaterial(${region}, 4, ${material(options.replaceMaterial)}, ${target})` : `Terrain:FillRegion(${region}, 4, ${target})`;
   return [
     "local Terrain = workspace.Terrain",
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     op,
     'return { shape = "paint", success = true }'
   ].join("\n");
@@ -14137,6 +14909,7 @@ function buildPaintMaterialLuau(options) {
 function buildClearRegionLuau(options) {
   return [
     "local Terrain = workspace.Terrain",
+    "if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end",
     `Terrain:FillRegion(${region3(options.min, options.max)}, 4, Enum.Material.Air)`,
     'return { shape = "clear", success = true }'
   ].join("\n");
@@ -14217,6 +14990,8 @@ spawn.Anchored = true
 
 local checkpoints = ensure(course, "Checkpoints", "Folder")
 for i = 0, NUM_CHECKPOINTS do
+		if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
+	if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 	local cp = makePart(checkpoints, "Checkpoint" .. i, Vector3.new(10, 1, 10), Vector3.new(i * 40, 5, 0), Color3.fromRGB(80, 200, 120), true)
 	cp:SetAttribute("Stage", i)
 	if i > 0 then
@@ -14443,6 +15218,8 @@ local arena = ensure(Workspace, "Arena", "Model")
 makePart(arena, "ArenaFloor", Vector3.new(120, 1, 120), Vector3.new(300, 5, 0), Color3.fromRGB(110, 110, 120), true)
 local teleports = ensure(arena, "TeleportPoints", "Folder")
 for i = 1, NUM_TELEPORTS do
+		if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
+	if _G.__mcp and _G.__mcp.checkCancelled and _G.__mcp.checkCancelled() then return { cancelled = true } end
 	local angle = (i / NUM_TELEPORTS) * math.pi * 2
 	local tp = makePart(teleports, "Teleport" .. i, Vector3.new(6, 1, 6), Vector3.new(300 + math.cos(angle) * 40, 6, math.sin(angle) * 40), Color3.fromRGB(120, 120, 255), true)
 	tp.Transparency = 0.5
@@ -14709,8 +15486,8 @@ var init_sync_luau = __esm({
 });
 
 // ../core/dist/tools/sync-tools.js
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 var SyncTools;
 var init_sync_tools = __esm({
   "../core/dist/tools/sync-tools.js"() {
@@ -14730,11 +15507,11 @@ var init_sync_tools = __esm({
       // clobbering. SyncManager owns the (tested) path/conflict logic; this layer
       // owns filesystem and Studio I/O.
       _syncManifestPath(dir) {
-        return path3.join(dir, ".robloxsync.json");
+        return path4.join(dir, ".robloxsync.json");
       }
       _readManifest(dir) {
         try {
-          const raw = fs3.readFileSync(this._syncManifestPath(dir), "utf8");
+          const raw = fs4.readFileSync(this._syncManifestPath(dir), "utf8");
           const parsed = JSON.parse(raw);
           return parsed && typeof parsed.paths === "object" ? parsed.paths : {};
         } catch {
@@ -14743,7 +15520,7 @@ var init_sync_tools = __esm({
       }
       _writeManifest(dir, paths) {
         const payload = { version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), paths };
-        fs3.writeFileSync(this._syncManifestPath(dir), JSON.stringify(payload, null, 2));
+        fs4.writeFileSync(this._syncManifestPath(dir), JSON.stringify(payload, null, 2));
       }
       async _dumpStudioScripts(instance_id) {
         const response = await this.runtime.callSingle("/api/execute-luau", { code: buildDumpScriptsLuau() }, "edit", instance_id);
@@ -14766,17 +15543,17 @@ var init_sync_tools = __esm({
         const walk = (current) => {
           let entries;
           try {
-            entries = fs3.readdirSync(current, { withFileTypes: true });
+            entries = fs4.readdirSync(current, { withFileTypes: true });
           } catch {
             return;
           }
           for (const entry of entries) {
-            const full = path3.join(current, entry.name);
-            const rel = path3.relative(dir, full).split(path3.sep).join("/");
+            const full = path4.join(current, entry.name);
+            const rel = path4.relative(dir, full).split(path4.sep).join("/");
             if (entry.isDirectory()) {
               walk(full);
             } else if (this.sync.classNameForFile(entry.name) && !this.sync.isIgnored(rel)) {
-              out.set(rel, fs3.readFileSync(full, "utf8"));
+              out.set(rel, fs4.readFileSync(full, "utf8"));
             }
           }
         };
@@ -14784,12 +15561,12 @@ var init_sync_tools = __esm({
         return out;
       }
       _resolveSyncDir(syncDir) {
-        return path3.resolve(syncDir ?? process.env.ROBLOX_SYNC_DIR ?? path3.join(process.cwd(), "roblox-src"));
+        return path4.resolve(syncDir ?? process.env.ROBLOX_SYNC_DIR ?? path4.join(process.cwd(), "roblox-src"));
       }
       async syncPull(syncDir, instance_id) {
         const dir = this._resolveSyncDir(syncDir);
         const scripts = await this._dumpStudioScripts(instance_id);
-        fs3.mkdirSync(dir, { recursive: true });
+        fs4.mkdirSync(dir, { recursive: true });
         const manifest = {};
         let written = 0;
         let skipped = 0;
@@ -14799,9 +15576,9 @@ var init_sync_tools = __esm({
             skipped++;
             continue;
           }
-          const full = path3.join(dir, rel);
-          fs3.mkdirSync(path3.dirname(full), { recursive: true });
-          fs3.writeFileSync(full, script.source);
+          const full = path4.join(dir, rel);
+          fs4.mkdirSync(path4.dirname(full), { recursive: true });
+          fs4.writeFileSync(full, script.source);
           manifest[rel] = script.source;
           written++;
         }
@@ -15126,7 +15903,7 @@ var init_opencloud_client = __esm({
           if (result.error) {
             throw new Error(`Asset upload failed: ${result.error.message}`);
           }
-          await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
+          await new Promise((resolve7) => setTimeout(resolve7, intervalMs));
         }
         throw new Error(`Asset upload timed out after ${maxAttempts * intervalMs / 1e3}s. Operation ID: ${operationId}`);
       }
@@ -15135,20 +15912,34 @@ var init_opencloud_client = __esm({
 });
 
 // ../core/dist/managed-instance-registry.js
-import * as fs4 from "fs";
-import * as os2 from "os";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as os3 from "os";
+import * as path5 from "path";
 function defaultManagedInstanceRegistryDir() {
+  if (process.env.BLOXFORGE_MANAGED_INSTANCE_REGISTRY_DIR) {
+    return process.env.BLOXFORGE_MANAGED_INSTANCE_REGISTRY_DIR;
+  }
   if (process.env.ROBLOXSTUDIO_MCP_MANAGED_INSTANCE_REGISTRY_DIR) {
     return process.env.ROBLOXSTUDIO_MCP_MANAGED_INSTANCE_REGISTRY_DIR;
   }
+  const suffix = path5.join("managed-instances", "v1");
+  let newDir;
+  let legacyDir;
   if (process.platform === "win32" && process.env.LOCALAPPDATA) {
-    return path4.join(process.env.LOCALAPPDATA, "robloxstudio-mcp", "managed-instances", "v1");
-  }
-  if (process.platform === "darwin") {
-    return path4.join(os2.homedir(), "Library", "Application Support", "robloxstudio-mcp", "managed-instances", "v1");
+    newDir = path5.join(process.env.LOCALAPPDATA, "bloxforge", suffix);
+    legacyDir = path5.join(process.env.LOCALAPPDATA, "robloxstudio-mcp", suffix);
+  } else if (process.platform === "darwin") {
+    newDir = path5.join(os3.homedir(), "Library", "Application Support", "bloxforge", suffix);
+    legacyDir = path5.join(os3.homedir(), "Library", "Application Support", "robloxstudio-mcp", suffix);
+  } else {
+    newDir = path5.join(os3.homedir(), ".local", "state", "bloxforge", suffix);
+    legacyDir = path5.join(os3.homedir(), ".local", "state", "robloxstudio-mcp", suffix);
   }
-  return path4.join(os2.homedir(), ".local", "state", "robloxstudio-mcp", "managed-instances", "v1");
+  if (fs5.existsSync(newDir))
+    return newDir;
+  if (fs5.existsSync(legacyDir))
+    return legacyDir;
+  return newDir;
 }
 function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
@@ -15228,20 +16019,20 @@ var init_managed_instance_registry = __esm({
       }
       withLock(fn) {
         this.ensureDir();
-        const lockDir = path4.join(this.dir, ".lock");
+        const lockDir = path5.join(this.dir, ".lock");
         const deadline = Date.now() + LOCK_TIMEOUT_MS;
         while (true) {
           try {
-            fs4.mkdirSync(lockDir);
+            fs5.mkdirSync(lockDir);
             break;
           } catch (error) {
             const code = error.code;
             if (code !== "EEXIST")
               throw error;
             try {
-              const stat = fs4.statSync(lockDir);
+              const stat = fs5.statSync(lockDir);
               if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-                fs4.rmSync(lockDir, { recursive: true, force: true });
+                fs5.rmSync(lockDir, { recursive: true, force: true });
                 continue;
               }
             } catch {
@@ -15256,21 +16047,21 @@ var init_managed_instance_registry = __esm({
         try {
           return fn();
         } finally {
-          fs4.rmSync(lockDir, { recursive: true, force: true });
+          fs5.rmSync(lockDir, { recursive: true, force: true });
         }
       }
       ensureDir() {
-        fs4.mkdirSync(this.dir, { recursive: true });
+        fs5.mkdirSync(this.dir, { recursive: true });
       }
       recordPath(recordId) {
-        return path4.join(this.dir, `${recordId}.json`);
+        return path5.join(this.dir, `${recordId}.json`);
       }
       recordFilesUnlocked() {
-        return fs4.readdirSync(this.dir).filter((name) => name.endsWith(".json")).map((name) => path4.join(this.dir, name));
+        return fs5.readdirSync(this.dir).filter((name) => name.endsWith(".json")).map((name) => path5.join(this.dir, name));
       }
       readRecordUnlocked(recordId) {
         try {
-          const parsed = JSON.parse(fs4.readFileSync(this.recordPath(recordId), "utf8"));
+          const parsed = JSON.parse(fs5.readFileSync(this.recordPath(recordId), "utf8"));
           return isRecord(parsed) ? parsed : void 0;
         } catch {
           return void 0;
@@ -15283,7 +16074,7 @@ var init_managed_instance_registry = __esm({
         const records = [];
         for (const file of this.recordFilesUnlocked()) {
           try {
-            const parsed = JSON.parse(fs4.readFileSync(file, "utf8"));
+            const parsed = JSON.parse(fs5.readFileSync(file, "utf8"));
             if (!isRecord(parsed))
               continue;
             records.push(parsed);
@@ -15295,23 +16086,23 @@ var init_managed_instance_registry = __esm({
       writeRecordUnlocked(record) {
         this.ensureDir();
         const finalPath = this.recordPath(record.recordId);
-        const tmpPath = path4.join(this.dir, `${record.recordId}.${process.pid}.${Date.now()}.tmp`);
-        const fd = fs4.openSync(tmpPath, "w");
+        const tmpPath = path5.join(this.dir, `${record.recordId}.${process.pid}.${Date.now()}.tmp`);
+        const fd = fs5.openSync(tmpPath, "w");
         try {
-          fs4.writeFileSync(fd, `${JSON.stringify(record, null, 2)}
+          fs5.writeFileSync(fd, `${JSON.stringify(record, null, 2)}
 `, "utf8");
-          fs4.fsyncSync(fd);
+          fs5.fsyncSync(fd);
         } finally {
-          fs4.closeSync(fd);
+          fs5.closeSync(fd);
         }
-        fs4.renameSync(tmpPath, finalPath);
+        fs5.renameSync(tmpPath, finalPath);
       }
       deleteRecordUnlocked(recordId) {
-        fs4.rmSync(this.recordPath(recordId), { force: true });
+        fs5.rmSync(this.recordPath(recordId), { force: true });
       }
       appendEventUnlocked(event, now) {
-        const file = path4.join(this.dir, `events-${ymd(now)}.jsonl`);
-        fs4.appendFileSync(file, `${JSON.stringify({
+        const file = path5.join(this.dir, `events-${ymd(now)}.jsonl`);
+        fs5.appendFileSync(file, `${JSON.stringify({
           ts: new Date(now).toISOString(),
           ...event
         })}
@@ -15319,12 +16110,12 @@ var init_managed_instance_registry = __esm({
       }
       cleanupOldEventLogsUnlocked(now) {
         const cutoff = ymd(now - EVENT_RETENTION_DAYS * 24 * 60 * 60 * 1e3);
-        for (const name of fs4.readdirSync(this.dir)) {
+        for (const name of fs5.readdirSync(this.dir)) {
           const date = eventLogDate(name);
           if (!date || date >= cutoff)
             continue;
           try {
-            fs4.rmSync(path4.join(this.dir, name), { force: true });
+            fs5.rmSync(path5.join(this.dir, name), { force: true });
           } catch {
           }
         }
@@ -15348,9 +16139,9 @@ var init_managed_instance_registry = __esm({
         for (const file of this.recordFilesUnlocked()) {
           let parsed;
           try {
-            parsed = JSON.parse(fs4.readFileSync(file, "utf8"));
+            parsed = JSON.parse(fs5.readFileSync(file, "utf8"));
           } catch {
-            fs4.rmSync(file, { force: true });
+            fs5.rmSync(file, { force: true });
             this.appendEventUnlocked({
               event: "registry_pruned_malformed_record",
               reason: "parse_error",
@@ -15359,7 +16150,7 @@ var init_managed_instance_registry = __esm({
             continue;
           }
           if (!parsed || typeof parsed !== "object") {
-            fs4.rmSync(file, { force: true });
+            fs5.rmSync(file, { force: true });
             this.appendEventUnlocked({
               event: "registry_pruned_malformed_record",
               reason: "invalid_shape",
@@ -15371,7 +16162,7 @@ var init_managed_instance_registry = __esm({
           if (typeof version === "number" && version > REGISTRY_VERSION)
             continue;
           if (!isRecord(parsed)) {
-            fs4.rmSync(file, { force: true });
+            fs5.rmSync(file, { force: true });
             this.appendEventUnlocked({
               event: "registry_pruned_malformed_record",
               reason: "invalid_shape",
@@ -15380,7 +16171,7 @@ var init_managed_instance_registry = __esm({
             continue;
           }
           if (parsed.closedAt !== void 0) {
-            fs4.rmSync(file, { force: true });
+            fs5.rmSync(file, { force: true });
             this.appendEventUnlocked({
               event: "registry_pruned_closed_record",
               recordId: parsed.recordId,
@@ -15393,7 +16184,7 @@ var init_managed_instance_registry = __esm({
           }
           if (parsed.bootId !== options.currentBootId) {
             this.cleanupRecord(options, parsed);
-            fs4.rmSync(file, { force: true });
+            fs5.rmSync(file, { force: true });
             this.appendEventUnlocked({
               event: "registry_pruned_previous_boot",
               recordId: parsed.recordId,
@@ -15406,7 +16197,7 @@ var init_managed_instance_registry = __esm({
           }
           if (options.isProcessRunning && (parsed.nativeProcessId || parsed.spawnPid) && !options.isProcessRunning(parsed)) {
             this.cleanupRecord(options, parsed);
-            fs4.rmSync(file, { force: true });
+            fs5.rmSync(file, { force: true });
             this.appendEventUnlocked({
               event: "registry_pruned_stale_process",
               recordId: parsed.recordId,
@@ -15424,10 +16215,10 @@ var init_managed_instance_registry = __esm({
 
 // ../core/dist/studio-instance-manager.js
 import { execFileSync, spawn } from "child_process";
-import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync4, realpathSync, rmSync as rmSync2, statSync as statSync3 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync5, realpathSync, rmSync as rmSync2, statSync as statSync3 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import * as os3 from "os";
-import * as path5 from "path";
+import * as os4 from "os";
+import * as path6 from "path";
 function run(command, args, options = {}) {
   return execFileSync(command, args, {
     encoding: "utf8",
@@ -15439,14 +16230,14 @@ function isWsl() {
   if (process.platform !== "linux")
     return false;
   try {
-    return /microsoft|wsl/i.test(readFileSync4("/proc/version", "utf8"));
+    return /microsoft|wsl/i.test(readFileSync5("/proc/version", "utf8"));
   } catch {
     return false;
   }
 }
 function powershell(script) {
   return run("powershell.exe", ["-NoProfile", "-Command", script], {
-    cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
+    cwd: isWsl() && existsSync4("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
   });
 }
 function windowsLocalAppData() {
@@ -15456,7 +16247,7 @@ function windowsLocalAppData() {
     return void 0;
   try {
     return run("cmd.exe", ["/c", "echo %LOCALAPPDATA%"], {
-      cwd: existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
+      cwd: existsSync4("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
     });
   } catch {
     return void 0;
@@ -15468,7 +16259,7 @@ function toWslPath(windowsPath) {
   return run("wslpath", ["-u", windowsPath]);
 }
 function toStudioLaunchArg(arg) {
-  if (!isWsl() || !path5.isAbsolute(arg) || !existsSync2(arg))
+  if (!isWsl() || !path6.isAbsolute(arg) || !existsSync4(arg))
     return arg;
   return run("wslpath", ["-w", arg]);
 }
@@ -15477,24 +16268,24 @@ function resolveEntrypointDir() {
   if (!entrypoint)
     return void 0;
   try {
-    return path5.dirname(realpathSync(entrypoint));
+    return path6.dirname(realpathSync(entrypoint));
   } catch {
-    return path5.dirname(path5.resolve(entrypoint));
+    return path6.dirname(path6.resolve(entrypoint));
   }
 }
 function resolveBaseplateTemplatePath() {
   const entrypointDir = resolveEntrypointDir();
   const candidates = [
     ...entrypointDir ? [
-      path5.join(entrypointDir, "assets", BASEPLATE_TEMPLATE_NAME),
-      path5.join(entrypointDir, "..", "assets", BASEPLATE_TEMPLATE_NAME)
+      path6.join(entrypointDir, "assets", BASEPLATE_TEMPLATE_NAME),
+      path6.join(entrypointDir, "..", "assets", BASEPLATE_TEMPLATE_NAME)
     ] : [],
-    path5.join(process.cwd(), "packages", "core", "assets", BASEPLATE_TEMPLATE_NAME),
-    path5.join(process.cwd(), "packages", "robloxstudio-mcp", "dist", "assets", BASEPLATE_TEMPLATE_NAME),
-    path5.join(process.cwd(), "assets", BASEPLATE_TEMPLATE_NAME)
+    path6.join(process.cwd(), "packages", "core", "assets", BASEPLATE_TEMPLATE_NAME),
+    path6.join(process.cwd(), "packages", "robloxstudio-mcp", "dist", "assets", BASEPLATE_TEMPLATE_NAME),
+    path6.join(process.cwd(), "assets", BASEPLATE_TEMPLATE_NAME)
   ];
   for (const candidate of candidates) {
-    if (existsSync2(candidate))
+    if (existsSync4(candidate))
       return candidate;
   }
   throw new Error(`Baseplate template not found. Expected ${BASEPLATE_TEMPLATE_NAME} in one of: ${candidates.join(", ")}`);
@@ -15521,7 +16312,7 @@ function sweepStaleBaseplateFiles() {
       continue;
     if (Number(match[1]) !== process.pid && isProcessAlive(Number(match[1])))
       continue;
-    const file = path5.join(BASEPLATE_TEMP_DIR, entry);
+    const file = path6.join(BASEPLATE_TEMP_DIR, entry);
     try {
       if (statSync3(file).mtimeMs < cutoff)
         rmSync2(file, { force: true });
@@ -15530,15 +16321,15 @@ function sweepStaleBaseplateFiles() {
   }
 }
 function createBaseplatePlaceFile() {
-  mkdirSync5(BASEPLATE_TEMP_DIR, { recursive: true });
+  mkdirSync6(BASEPLATE_TEMP_DIR, { recursive: true });
   sweepStaleBaseplateFiles();
-  const file = path5.join(BASEPLATE_TEMP_DIR, `Baseplate-${process.pid}-${Date.now()}.rbxl`);
-  copyFileSync(resolveBaseplateTemplatePath(), file);
+  const file = path6.join(BASEPLATE_TEMP_DIR, `Baseplate-${process.pid}-${Date.now()}.rbxl`);
+  copyFileSync2(resolveBaseplateTemplatePath(), file);
   return file;
 }
 function isGeneratedBaseplatePlaceFile(file) {
-  const resolvedFile = path5.resolve(file);
-  return path5.dirname(resolvedFile) === path5.resolve(BASEPLATE_TEMP_DIR) && BASEPLATE_TEMP_NAME.test(path5.basename(resolvedFile));
+  const resolvedFile = path6.resolve(file);
+  return path6.dirname(resolvedFile) === path6.resolve(BASEPLATE_TEMP_DIR) && BASEPLATE_TEMP_NAME.test(path6.basename(resolvedFile));
 }
 function cleanupManagedBaseplateFiles(record) {
   if (record.source !== "baseplate" || !record.localPlaceFile)
@@ -15570,11 +16361,11 @@ function resolveStudioExe() {
     throw new Error("Roblox Studio executable auto-discovery is only supported on Windows, WSL, and macOS. Set ROBLOX_STUDIO_EXE.");
   }
   const localAppData = windowsLocalAppData();
-  const root = localAppData ? path5.join(toWslPath(localAppData), "Roblox", "Versions") : path5.join(os3.homedir(), "AppData", "Local", "Roblox", "Versions");
-  if (!existsSync2(root)) {
+  const root = localAppData ? path6.join(toWslPath(localAppData), "Roblox", "Versions") : path6.join(os4.homedir(), "AppData", "Local", "Roblox", "Versions");
+  if (!existsSync4(root)) {
     throw new Error(`Roblox Studio Versions folder not found: ${root}. Set ROBLOX_STUDIO_EXE.`);
   }
-  const candidates = readdirSync4(root).filter((name) => name.startsWith("version-")).map((name) => path5.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync2(candidate)).sort((a, b) => statSync3(b).mtimeMs - statSync3(a).mtimeMs);
+  const candidates = readdirSync4(root).filter((name) => name.startsWith("version-")).map((name) => path6.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync4(candidate)).sort((a, b) => statSync3(b).mtimeMs - statSync3(a).mtimeMs);
   if (candidates.length === 0) {
     throw new Error(`RobloxStudioBeta.exe not found under ${root}. Set ROBLOX_STUDIO_EXE.`);
   }
@@ -15609,7 +16400,7 @@ function listStudioProcesses() {
 function currentBootId() {
   if (process.platform === "linux") {
     try {
-      return readFileSync4("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      return readFileSync5("/proc/sys/kernel/random/boot_id", "utf8").trim();
     } catch {
     }
   }
@@ -15625,7 +16416,7 @@ function currentBootId() {
     } catch {
     }
   }
-  return `${process.platform}:${os3.hostname()}:unknown-boot`;
+  return `${process.platform}:${os4.hostname()}:unknown-boot`;
 }
 function buildStudioLaunchArgs(options) {
   switch (options.source) {
@@ -15661,17 +16452,17 @@ function buildStudioLaunchArgs(options) {
   }
 }
 function delay(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 function basenameAny(filePath) {
-  return path5.basename(filePath.replace(/\\/g, "/"));
+  return path6.basename(filePath.replace(/\\/g, "/"));
 }
 var BASEPLATE_TEMP_DIR, BASEPLATE_TEMP_NAME, BASEPLATE_TEMPLATE_NAME, STALE_BASEPLATE_MAX_AGE_MS, BASEPLATE_TEMP_SWEEP_NAME, StudioInstanceManager;
 var init_studio_instance_manager = __esm({
   "../core/dist/studio-instance-manager.js"() {
     "use strict";
     init_managed_instance_registry();
-    BASEPLATE_TEMP_DIR = path5.join(os3.tmpdir(), "robloxstudio-mcp-baseplates");
+    BASEPLATE_TEMP_DIR = path6.join(os4.tmpdir(), "robloxstudio-mcp-baseplates");
     BASEPLATE_TEMP_NAME = /^Baseplate-\d+-\d+\.rbxl$/;
     BASEPLATE_TEMPLATE_NAME = "Baseplate.rbxl";
     STALE_BASEPLATE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
@@ -15720,7 +16511,7 @@ var init_studio_instance_manager = __esm({
         const exe = this.processAdapter.resolveStudioExe?.() ?? resolveStudioExe();
         const args = buildStudioLaunchArgs(preparedOptions).map(toStudioLaunchArg);
         const spawnOptions = {
-          cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd(),
+          cwd: isWsl() && existsSync4("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd(),
           detached: true,
           stdio: "ignore"
         };
@@ -15926,13 +16717,13 @@ var init_studio_instance_manager = __esm({
         const processId = record.nativeProcessId ?? record.spawnPid;
         if (record.spawnPid && record.spawnPid === processId && studioProcess.Id === processId)
           return true;
-        const processPath = studioProcess.Path ? path5.normalize(studioProcess.Path).toLowerCase() : "";
-        const exePath = record.exe ? path5.normalize(record.exe).toLowerCase() : "";
+        const processPath = studioProcess.Path ? path6.normalize(studioProcess.Path).toLowerCase() : "";
+        const exePath = record.exe ? path6.normalize(record.exe).toLowerCase() : "";
         if (processPath && exePath && (processPath === exePath || basenameAny(processPath) === basenameAny(exePath))) {
           return true;
         }
         const commandLine = studioProcess.CommandLine ?? "";
-        if (record.localPlaceFile && commandLine.includes(path5.basename(record.localPlaceFile)))
+        if (record.localPlaceFile && commandLine.includes(path6.basename(record.localPlaceFile)))
           return true;
         if (record.placeId !== void 0 && commandLine.includes(String(record.placeId)))
           return true;
@@ -16133,10 +16924,207 @@ var init_session_recorder = __esm({
   }
 });
 
+// ../core/dist/quality-tools.js
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs6 from "fs";
+import * as os5 from "os";
+import * as path7 from "path";
+function within(root, candidate) {
+  const relative3 = path7.relative(root, candidate);
+  return relative3 === "" || !relative3.startsWith("..") && !path7.isAbsolute(relative3);
+}
+function allowedProjectRoot(root) {
+  const candidate = path7.resolve(root);
+  if (process.env.NODE_ENV === "test")
+    return candidate;
+  const allowed = path7.resolve(process.env.BLOXFORGE_PROJECT_ROOT?.trim() || process.cwd());
+  if (!within(allowed, candidate))
+    throw new Error(`Project root must stay within ${allowed}`);
+  return candidate;
+}
+function hasCommand(command) {
+  try {
+    execFileSync2(command, ["--version"], { stdio: "pipe", timeout: 3e3 });
+    return true;
+  } catch (error) {
+    return error?.code !== "ENOENT";
+  }
+}
+function projectFiles(root) {
+  const names = [
+    "default.project.json",
+    "rojo.json",
+    "rojo.project.json",
+    "sourcemap.json",
+    "selene.toml",
+    "stylua.toml",
+    "wally.toml",
+    "wally.lock",
+    "rokit.toml",
+    "aftman.toml"
+  ];
+  return Object.fromEntries(names.map((name) => [name, fs6.existsSync(path7.join(root, name)) ? path7.join(root, name) : void 0]).filter((entry) => entry[1] !== void 0));
+}
+function run2(command, args, options = {}) {
+  if (!hasCommand(command))
+    return { tool: command, available: false, ok: false, error: `${command} is not installed` };
+  try {
+    const output = execFileSync2(command, args, {
+      cwd: options.cwd,
+      input: options.input,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 12e4,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return { tool: command, available: true, ok: true, output: output.trim() };
+  } catch (error) {
+    return {
+      tool: command,
+      available: true,
+      ok: false,
+      output: [error?.stdout, error?.stderr].filter(Boolean).join("\n").trim(),
+      error: error?.message ?? String(error),
+      exitCode: typeof error?.status === "number" ? error.status : void 0
+    };
+  }
+}
+var TOOL_COMMANDS, QualityTools;
+var init_quality_tools = __esm({
+  "../core/dist/quality-tools.js"() {
+    "use strict";
+    TOOL_COMMANDS = ["luau-analyze", "luau-lsp", "stylua", "selene", "rojo", "rokit", "wally", "lune"];
+    QualityTools = class {
+      detectRobloxProject(root = process.cwd()) {
+        const boundary = process.env.NODE_ENV === "test" ? path7.parse(path7.resolve(root)).root : path7.resolve(process.env.BLOXFORGE_PROJECT_ROOT?.trim() || process.cwd());
+        let current = allowedProjectRoot(root);
+        while (true) {
+          const files = projectFiles(current);
+          if (Object.keys(files).length > 0) {
+            return {
+              root: current,
+              files,
+              availableTools: TOOL_COMMANDS.filter(hasCommand)
+            };
+          }
+          const parent = path7.dirname(current);
+          if (parent === current || !within(boundary, parent))
+            break;
+          current = parent;
+        }
+        return { root: path7.resolve(root), files: {}, availableTools: TOOL_COMMANDS.filter(hasCommand) };
+      }
+      validateScriptSource(source, fileName = "script.server.lua") {
+        if (typeof source !== "string")
+          throw new Error("source is required");
+        const dir = fs6.mkdtempSync(path7.join(os5.tmpdir(), "bloxforge-quality-"));
+        const file = path7.join(dir, path7.basename(fileName));
+        fs6.writeFileSync(file, source, "utf8");
+        const checks = [
+          run2("luau-analyze", [file]),
+          run2("selene", [file]),
+          run2("stylua", ["--check", file])
+        ];
+        fs6.rmSync(dir, { recursive: true, force: true });
+        return { checks };
+      }
+      formatScriptPreview(source, fileName = "script.server.lua") {
+        if (typeof source !== "string")
+          throw new Error("source is required");
+        return run2("stylua", ["--stdin-filepath", fileName], { input: source });
+      }
+      resolveInstanceSourceFile(instancePath, root = process.cwd()) {
+        const project = this.detectRobloxProject(root);
+        const sourcemapPath = project.files["sourcemap.json"];
+        if (!sourcemapPath)
+          return { resolved: false, reason: "sourcemap.json not found", instancePath };
+        let sourcemap;
+        try {
+          sourcemap = JSON.parse(fs6.readFileSync(sourcemapPath, "utf8"));
+        } catch (error) {
+          return { resolved: false, reason: `invalid sourcemap: ${error instanceof Error ? error.message : String(error)}`, instancePath };
+        }
+        const target = instancePath.split(".").filter(Boolean).reduce((node, segment) => {
+          if (!node || typeof node !== "object")
+            return void 0;
+          return node.children?.find((child) => child.name === segment);
+        }, sourcemap);
+        return target ? { resolved: true, instancePath, node: target } : { resolved: false, instancePath, reason: "instance not found" };
+      }
+      getDependencyGraph(root = process.cwd()) {
+        const project = this.detectRobloxProject(root);
+        const lock = project.files["wally.lock"];
+        const dependencies = [];
+        if (lock) {
+          for (const line of fs6.readFileSync(lock, "utf8").split(/\r?\n/)) {
+            const match = line.match(/^\s*([\w.-]+)\s*=/);
+            if (match && match[1] !== "version")
+              dependencies.push(match[1]);
+          }
+        }
+        return { root: project.root, manifest: project.files["wally.toml"], lockfile: lock, dependencies: [...new Set(dependencies)] };
+      }
+      installWallyPackages(root = process.cwd(), confirm = false) {
+        if (!confirm)
+          return { tool: "wally", available: hasCommand("wally"), ok: false, error: "Confirmation required: pass confirm=true to install packages" };
+        return run2("wally", ["install"], { cwd: this.detectRobloxProject(root).root });
+      }
+      runProjectTests(root = process.cwd(), script) {
+        if (!script)
+          return { tool: "lune", available: hasCommand("lune"), ok: false, error: "script is required" };
+        const project = this.detectRobloxProject(root);
+        const scriptPath = path7.resolve(project.root, script);
+        if (!within(project.root, scriptPath))
+          return { tool: "lune", available: hasCommand("lune"), ok: false, error: "script must stay within project root" };
+        return run2("lune", ["run", scriptPath], { cwd: project.root });
+      }
+      validateWithLuauLsp(root = process.cwd(), files = ["."]) {
+        const project = this.detectRobloxProject(root);
+        const args = ["analyze", ...files];
+        if (project.files["sourcemap.json"])
+          args.push("--sourcemap", project.files["sourcemap.json"]);
+        return run2("luau-lsp", args, { cwd: project.root });
+      }
+      generateRojoSourcemap(root = process.cwd(), output = "sourcemap.json") {
+        const project = this.detectRobloxProject(root);
+        const projectFile = project.files["default.project.json"] ?? project.files["rojo.project.json"];
+        if (!projectFile)
+          return { tool: "rojo", available: hasCommand("rojo"), ok: false, error: "Rojo project file not found" };
+        const outputPath = path7.resolve(project.root, output);
+        if (!within(project.root, outputPath))
+          return { tool: "rojo", available: hasCommand("rojo"), ok: false, error: "output must stay within project root" };
+        return run2("rojo", ["sourcemap", projectFile, "--output", outputPath], { cwd: project.root });
+      }
+      buildRojoProject(root = process.cwd(), output) {
+        const project = this.detectRobloxProject(root);
+        const projectFile = project.files["default.project.json"] ?? project.files["rojo.project.json"];
+        if (!projectFile)
+          return { tool: "rojo", available: hasCommand("rojo"), ok: false, error: "Rojo project file not found" };
+        if (!output)
+          return { tool: "rojo", available: hasCommand("rojo"), ok: false, error: "output is required" };
+        const outputPath = path7.resolve(project.root, output);
+        if (!within(project.root, outputPath))
+          return { tool: "rojo", available: hasCommand("rojo"), ok: false, error: "output must stay within project root" };
+        return run2("rojo", ["build", projectFile, "--output", outputPath], { cwd: project.root });
+      }
+      runQualityGate(root = process.cwd()) {
+        const project = this.detectRobloxProject(root);
+        const checks = [
+          run2("rojo", ["sourcemap"], { cwd: project.root }),
+          run2("selene", ["."], { cwd: project.root }),
+          run2("stylua", ["--check", "."], { cwd: project.root }),
+          this.validateWithLuauLsp(project.root)
+        ];
+        return { project, checks };
+      }
+    };
+  }
+});
+
 // ../core/dist/tools/index.js
-import * as fs5 from "fs";
-import * as os4 from "os";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as os6 from "os";
+import * as path8 from "path";
 import * as crypto from "crypto";
 function requiresAttribution(license) {
   return /cc[\s-]?by|attribution/i.test(license ?? "");
@@ -16196,8 +17184,8 @@ function loadMicroProfilerBaseline(source, sourcePath) {
   if (sourcePath !== void 0) {
     if (typeof sourcePath !== "string" || sourcePath === "")
       throw new Error("baseline_path must be a non-empty string when provided");
-    const resolved = path6.resolve(sourcePath);
-    const parsed = JSON.parse(fs5.readFileSync(resolved, "utf8"));
+    const resolved = path8.resolve(sourcePath);
+    const parsed = JSON.parse(fs7.readFileSync(resolved, "utf8"));
     const record = asRecord(parsed);
     if (!record)
       throw new Error(`baseline_path did not contain a JSON object: ${resolved}`);
@@ -16329,6 +17317,7 @@ var init_tools = __esm({
     init_roblox_cookie_client();
     init_roblox_docs();
     init_session_recorder();
+    init_quality_tools();
     init_runtime_support();
     RobloxStudioTools = class _RobloxStudioTools {
       client;
@@ -16351,6 +17340,7 @@ var init_tools = __esm({
       runtimeTools;
       episodes;
       sessionRecorder;
+      qualityTools;
       /** Provenance for externally-imported assets (Track A) — source/license/hash/assetId. */
       provenance = /* @__PURE__ */ new Map();
       constructor(bridge) {
@@ -16388,7 +17378,7 @@ var init_tools = __esm({
         this.scriptTools = new ScriptTools({
           callSingle: this._callSingle.bind(this),
           safetyGate: this._safetyGate.bind(this),
-          backupScript: (path8, source) => this.safety.backupScript(path8, source),
+          backupScript: (path10, source) => this.safety.backupScript(path10, source),
           recordOperation: (kind, summary) => this.safety.recordOperation({ kind, summary })
         });
         this.mutationTools = new MutationTools({
@@ -16407,6 +17397,7 @@ var init_tools = __esm({
         });
         this.episodes = new EpisodeStore();
         this.sessionRecorder = new SessionRecorder();
+        this.qualityTools = new QualityTools();
         this.runtimeTools = new RuntimeTools({
           bridge: this.bridge,
           client: this.client,
@@ -16427,6 +17418,53 @@ var init_tools = __esm({
       async getSessionSummary() {
         return wrapToolJsonText(this.sessionRecorder.summarize());
       }
+      async getRequestStatus(requestId) {
+        if (!requestId)
+          throw new Error("requestId is required for get_request_status");
+        const status = await this.bridge.lookupRequestStatus(requestId);
+        return wrapToolJsonText(status ?? { error: "request_not_found", requestId });
+      }
+      async getTransportDiagnostics() {
+        return wrapToolJsonText(this.bridge.getTransportDiagnostics());
+      }
+      async cancelRequest(requestId) {
+        if (!requestId)
+          throw new Error("requestId is required for cancel_request");
+        return wrapToolJsonText({ requestId, cancelled: await this.bridge.requestCancellation(requestId) });
+      }
+      async detectRobloxProject(root) {
+        return wrapToolJsonText(this.qualityTools.detectRobloxProject(root));
+      }
+      async validateScriptSource(source, fileName) {
+        return wrapToolJsonText(this.qualityTools.validateScriptSource(source, fileName));
+      }
+      async formatScriptPreview(source, fileName) {
+        return wrapToolJsonText(this.qualityTools.formatScriptPreview(source, fileName));
+      }
+      async resolveInstanceSourceFile(instancePath, root) {
+        return wrapToolJsonText(this.qualityTools.resolveInstanceSourceFile(instancePath, root));
+      }
+      async runProjectTests(root, script) {
+        return wrapToolJsonText(this.qualityTools.runProjectTests(root, script));
+      }
+      async getDependencyGraph(root) {
+        return wrapToolJsonText(this.qualityTools.getDependencyGraph(root));
+      }
+      async installWallyPackages(root, confirm) {
+        return wrapToolJsonText(this.qualityTools.installWallyPackages(root, confirm));
+      }
+      async runQualityGate(root) {
+        return wrapToolJsonText(this.qualityTools.runQualityGate(root));
+      }
+      async validateWithLuauLsp(root, files) {
+        return wrapToolJsonText(this.qualityTools.validateWithLuauLsp(root, files));
+      }
+      async generateRojoSourcemap(root, output) {
+        return wrapToolJsonText(this.qualityTools.generateRojoSourcemap(root, output));
+      }
+      async buildRojoProject(root, output) {
+        return wrapToolJsonText(this.qualityTools.buildRojoProject(root, output));
+      }
       async getRobloxDocs(name, docType, section) {
         if (!name || typeof name !== "string") {
           throw new Error('get_roblox_docs requires a name (e.g. "ProximityPrompt")');
@@ -16604,8 +17642,8 @@ var init_tools = __esm({
       }
       // Scene-read inspection tools live in SceneReadTools; the facade delegates with
       // identical signatures.
-      async getFileTree(path8 = "", instance_id) {
-        return this.sceneReadTools.getFileTree(path8, instance_id);
+      async getFileTree(path10 = "", instance_id) {
+        return this.sceneReadTools.getFileTree(path10, instance_id);
       }
       async searchFiles(query, searchType = "name", instance_id) {
         const response = await this._callSingle("/api/search-files", { query, searchType }, void 0, instance_id);
@@ -16639,8 +17677,8 @@ var init_tools = __esm({
       async getClassInfo(className, instance_id) {
         return this.sceneReadTools.getClassInfo(className, instance_id);
       }
-      async getProjectStructure(path8, maxDepth, scriptsOnly, instance_id) {
-        return this.sceneReadTools.getProjectStructure(path8, maxDepth, scriptsOnly, instance_id);
+      async getProjectStructure(path10, maxDepth, scriptsOnly, instance_id) {
+        return this.sceneReadTools.getProjectStructure(path10, maxDepth, scriptsOnly, instance_id);
       }
       // Mutation tools live in MutationTools; the facade delegates with identical signatures.
       async setProperty(instancePath, propertyName, propertyValue, instance_id) {
@@ -16824,14 +17862,14 @@ var init_tools = __esm({
         return this.runtimeTools.redo(instance_id);
       }
       static findProjectRoot(startDir) {
-        let dir = path6.resolve(startDir);
+        let dir = path8.resolve(startDir);
         let previous = "";
         while (dir !== previous) {
-          if (fs5.existsSync(path6.join(dir, ".git")) || fs5.existsSync(path6.join(dir, "package.json"))) {
+          if (fs7.existsSync(path8.join(dir, ".git")) || fs7.existsSync(path8.join(dir, "package.json"))) {
             return dir;
           }
           previous = dir;
-          dir = path6.dirname(dir);
+          dir = path8.dirname(dir);
         }
         return null;
       }
@@ -16839,15 +17877,15 @@ var init_tools = __esm({
         if (!candidate)
           return false;
         try {
-          return fs5.statSync(candidate).isDirectory();
+          return fs7.statSync(candidate).isDirectory();
         } catch {
           return false;
         }
       }
       static ensureWritableDirectory(candidate, label) {
-        const resolved = path6.resolve(candidate);
+        const resolved = path8.resolve(candidate);
         try {
-          fs5.mkdirSync(resolved, { recursive: true });
+          fs7.mkdirSync(resolved, { recursive: true });
         } catch (error) {
           throw new Error(`Unable to create ${label} build-library directory at ${resolved}: ${error.message}`);
         }
@@ -16855,7 +17893,7 @@ var init_tools = __esm({
           throw new Error(`${label} build-library path is not a directory: ${resolved}`);
         }
         try {
-          fs5.accessSync(resolved, fs5.constants.W_OK);
+          fs7.accessSync(resolved, fs7.constants.W_OK);
         } catch (error) {
           throw new Error(`${label} build-library directory is not writable: ${resolved}. ${error.message}`);
         }
@@ -16865,26 +17903,28 @@ var init_tools = __esm({
       static findLibraryPath() {
         if (_RobloxStudioTools._cachedLibraryPath)
           return _RobloxStudioTools._cachedLibraryPath;
-        const overridePath = process.env.ROBLOXSTUDIO_MCP_BUILD_LIBRARY || process.env.BUILD_LIBRARY_PATH;
-        const cwd = path6.resolve(process.cwd());
+        const overridePath = process.env.BLOXFORGE_BUILD_LIBRARY || process.env.ROBLOXSTUDIO_MCP_BUILD_LIBRARY || process.env.BUILD_LIBRARY_PATH;
+        const cwd = path8.resolve(process.cwd());
         const projectRoot = _RobloxStudioTools.findProjectRoot(cwd);
-        const homeLibraryPath = path6.join(os4.homedir(), ".robloxstudio-mcp", "build-library");
-        const projectLibraryPath = projectRoot ? path6.join(projectRoot, "build-library") : null;
-        const cwdLibraryPath = path6.join(cwd, "build-library");
+        const newHomeLibraryPath = path8.join(os6.homedir(), ".bloxforge", "build-library");
+        const legacyHomeLibraryPath = path8.join(os6.homedir(), ".robloxstudio-mcp", "build-library");
+        const homeLibraryPath = fs7.existsSync(newHomeLibraryPath) ? newHomeLibraryPath : fs7.existsSync(legacyHomeLibraryPath) ? legacyHomeLibraryPath : newHomeLibraryPath;
+        const projectLibraryPath = projectRoot ? path8.join(projectRoot, "build-library") : null;
+        const cwdLibraryPath = path8.join(cwd, "build-library");
         let result;
         if (overridePath) {
           result = _RobloxStudioTools.ensureWritableDirectory(overridePath, "override");
         } else {
           const existing = [projectLibraryPath, cwdLibraryPath].find((c) => c && _RobloxStudioTools.isDirectory(c) && (() => {
             try {
-              fs5.accessSync(c, fs5.constants.W_OK);
+              fs7.accessSync(c, fs7.constants.W_OK);
               return true;
             } catch {
               return false;
             }
           })());
           if (existing) {
-            result = path6.resolve(existing);
+            result = path8.resolve(existing);
           } else if (projectLibraryPath) {
             try {
               result = _RobloxStudioTools.ensureWritableDirectory(projectLibraryPath, "project-root");
@@ -16911,12 +17951,12 @@ var init_tools = __esm({
         if (response && response.success && response.buildData) {
           const buildData = response.buildData;
           const buildId = buildData.id || `${style}/exported`;
-          const filePath = path6.join(_RobloxStudioTools.findLibraryPath(), `${buildId}.json`);
-          const dirPath = path6.dirname(filePath);
-          if (!fs5.existsSync(dirPath)) {
-            fs5.mkdirSync(dirPath, { recursive: true });
+          const filePath = path8.join(_RobloxStudioTools.findLibraryPath(), `${buildId}.json`);
+          const dirPath = path8.dirname(filePath);
+          if (!fs7.existsSync(dirPath)) {
+            fs7.mkdirSync(dirPath, { recursive: true });
           }
-          fs5.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
+          fs7.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
           response.savedTo = filePath;
         }
         return {
@@ -17013,12 +18053,12 @@ var init_tools = __esm({
         const normalizedParts = this.normalizeBuildParts(parts, new Set(Object.keys(normalizedPalette)));
         const computedBounds = bounds || this.computeBounds(normalizedParts);
         const buildData = { id, style, bounds: computedBounds, palette: normalizedPalette, parts: normalizedParts };
-        const filePath = path6.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
-        const dirPath = path6.dirname(filePath);
-        if (!fs5.existsSync(dirPath)) {
-          fs5.mkdirSync(dirPath, { recursive: true });
+        const filePath = path8.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
+        const dirPath = path8.dirname(filePath);
+        if (!fs7.existsSync(dirPath)) {
+          fs7.mkdirSync(dirPath, { recursive: true });
         }
-        fs5.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
+        fs7.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
         return {
           content: [
             {
@@ -17072,12 +18112,12 @@ var init_tools = __esm({
         };
         if (seed !== void 0)
           buildData.generatorSeed = seed;
-        const filePath = path6.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
-        const dirPath = path6.dirname(filePath);
-        if (!fs5.existsSync(dirPath)) {
-          fs5.mkdirSync(dirPath, { recursive: true });
+        const filePath = path8.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
+        const dirPath = path8.dirname(filePath);
+        if (!fs7.existsSync(dirPath)) {
+          fs7.mkdirSync(dirPath, { recursive: true });
         }
-        fs5.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
+        fs7.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
         return {
           content: [
             {
@@ -17101,17 +18141,17 @@ var init_tools = __esm({
         }
         let resolved;
         if (typeof buildData === "string") {
-          const filePath = path6.join(_RobloxStudioTools.findLibraryPath(), `${buildData}.json`);
-          if (!fs5.existsSync(filePath)) {
+          const filePath = path8.join(_RobloxStudioTools.findLibraryPath(), `${buildData}.json`);
+          if (!fs7.existsSync(filePath)) {
             throw new Error(`Build not found in library: ${buildData}`);
           }
-          resolved = JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+          resolved = JSON.parse(fs7.readFileSync(filePath, "utf-8"));
         } else if (buildData.id && !buildData.parts) {
-          const filePath = path6.join(_RobloxStudioTools.findLibraryPath(), `${buildData.id}.json`);
-          if (!fs5.existsSync(filePath)) {
+          const filePath = path8.join(_RobloxStudioTools.findLibraryPath(), `${buildData.id}.json`);
+          if (!fs7.existsSync(filePath)) {
             throw new Error(`Build not found in library: ${buildData.id}`);
           }
-          resolved = JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+          resolved = JSON.parse(fs7.readFileSync(filePath, "utf-8"));
         } else {
           resolved = buildData;
         }
@@ -17134,13 +18174,13 @@ var init_tools = __esm({
         const styles = style ? [style] : ["medieval", "modern", "nature", "scifi", "misc"];
         const builds = [];
         for (const s of styles) {
-          const dirPath = path6.join(libraryPath, s);
-          if (!fs5.existsSync(dirPath))
+          const dirPath = path8.join(libraryPath, s);
+          if (!fs7.existsSync(dirPath))
             continue;
-          const files = fs5.readdirSync(dirPath).filter((f) => f.endsWith(".json"));
+          const files = fs7.readdirSync(dirPath).filter((f) => f.endsWith(".json"));
           for (const file of files) {
             try {
-              const content = fs5.readFileSync(path6.join(dirPath, file), "utf-8");
+              const content = fs7.readFileSync(path8.join(dirPath, file), "utf-8");
               const data = JSON.parse(content);
               builds.push({
                 id: data.id || `${s}/${file.replace(".json", "")}`,
@@ -17179,11 +18219,11 @@ var init_tools = __esm({
         if (!id) {
           throw new Error("Build ID is required for get_build");
         }
-        const filePath = path6.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
-        if (!fs5.existsSync(filePath)) {
+        const filePath = path8.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
+        if (!fs7.existsSync(filePath)) {
           throw new Error(`Build not found in library: ${id}`);
         }
-        const data = JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+        const data = JSON.parse(fs7.readFileSync(filePath, "utf-8"));
         const result = {
           id: data.id,
           style: data.style,
@@ -17266,11 +18306,11 @@ var init_tools = __esm({
           if (!buildId) {
             throw new Error(`Invalid ${validatedKeyPath}: model key "${modelKey}" is not defined in sceneData.models`);
           }
-          const filePath = path6.join(libraryPath, `${buildId}.json`);
-          if (!fs5.existsSync(filePath)) {
+          const filePath = path8.join(libraryPath, `${buildId}.json`);
+          if (!fs7.existsSync(filePath)) {
             throw new Error(`Build not found in library: ${buildId}`);
           }
-          const content = fs5.readFileSync(filePath, "utf-8");
+          const content = fs7.readFileSync(filePath, "utf-8");
           const buildData = JSON.parse(content);
           const buildName = buildId.split("/").pop() || buildId;
           expandedBuilds.push({
@@ -17585,10 +18625,10 @@ var init_tools = __esm({
         this.safety.recordOperation({ kind: "audio", summary: `sound ${options.soundId} under ${options.parentPath}` });
         return result;
       }
-      async audioPlaySound(path8, instance_id) {
-        if (!path8)
+      async audioPlaySound(path10, instance_id) {
+        if (!path10)
           throw new Error("path is required for audio_play_sound");
-        return this._runGeneratedLuau(buildPlaySoundLuau({ path: path8 }), instance_id);
+        return this._runGeneratedLuau(buildPlaySoundLuau({ path: path10 }), instance_id);
       }
       async animationCreate(options, instance_id) {
         if (!options?.parentPath || options?.animationId === void 0)
@@ -17695,21 +18735,21 @@ var init_tools = __esm({
           if (!res.ok)
             return { content: [{ type: "text", text: JSON.stringify({ error: `Download failed: HTTP ${res.status} for ${options.source}` }) }] };
           const buf = Buffer.from(await res.arrayBuffer());
-          const ext = path6.extname(new URL(options.source).pathname) || ".bin";
-          filePath = path6.join(os4.tmpdir(), `mcp-ext-${Date.now()}${ext}`);
-          fs5.writeFileSync(filePath, buf);
+          const ext = path8.extname(new URL(options.source).pathname) || ".bin";
+          filePath = path8.join(os6.tmpdir(), `mcp-ext-${Date.now()}${ext}`);
+          fs7.writeFileSync(filePath, buf);
           bytes = buf.length;
           cleanup = true;
         } else {
-          if (!fs5.existsSync(options.source))
+          if (!fs7.existsSync(options.source))
             throw new Error(`File not found: ${options.source}`);
           filePath = options.source;
-          bytes = fs5.statSync(filePath).size;
+          bytes = fs7.statSync(filePath).size;
         }
-        const sha256 = crypto.createHash("sha256").update(fs5.readFileSync(filePath)).digest("hex");
+        const sha256 = crypto.createHash("sha256").update(fs7.readFileSync(filePath)).digest("hex");
         let uploadRaw = {};
         try {
-          const up = await this.uploadAsset(filePath, assetType, options.displayName ?? options.sourceName ?? path6.basename(filePath));
+          const up = await this.uploadAsset(filePath, assetType, options.displayName ?? options.sourceName ?? path8.basename(filePath));
           const text = up.content?.find((c) => "text" in c)?.text ?? "{}";
           uploadRaw = JSON.parse(text);
         } catch (error) {
@@ -17717,7 +18757,7 @@ var init_tools = __esm({
         } finally {
           if (cleanup) {
             try {
-              fs5.unlinkSync(filePath);
+              fs7.unlinkSync(filePath);
             } catch {
             }
           }
@@ -17776,10 +18816,10 @@ var init_tools = __esm({
         const { buffer, contentType } = await this.imageClient.generate(prompt, options ?? {});
         const ext = contentType.includes("png") ? "png" : "jpg";
         const slug = prompt.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "image";
-        const dir = path6.resolve(process.env.ROBLOX_IMAGE_DIR ?? path6.join(process.cwd(), "generated-images"));
-        fs5.mkdirSync(dir, { recursive: true });
-        const file = path6.join(dir, `${slug}-${Date.now()}.${ext}`);
-        fs5.writeFileSync(file, buffer);
+        const dir = path8.resolve(process.env.ROBLOX_IMAGE_DIR ?? path8.join(process.cwd(), "generated-images"));
+        fs7.mkdirSync(dir, { recursive: true });
+        const file = path8.join(dir, `${slug}-${Date.now()}.${ext}`);
+        fs7.writeFileSync(file, buffer);
         return { file, bytes: buffer.length, model: options?.model ?? DEFAULT_IMAGE_MODEL };
       }
       async imageGenerate(prompt, options) {
@@ -17845,11 +18885,11 @@ var init_tools = __esm({
         return null;
       }
       async uploadAsset(filePath, assetType, displayName, description, userId, groupId) {
-        if (!fs5.existsSync(filePath)) {
+        if (!fs7.existsSync(filePath)) {
           throw new Error(`File not found: ${filePath}`);
         }
-        const fileContent = fs5.readFileSync(filePath);
-        const fileName = path6.basename(filePath);
+        const fileContent = fs7.readFileSync(filePath);
+        const fileName = path8.basename(filePath);
         if (assetType === "Decal" && this.cookieClient.hasCookie()) {
           const result2 = await this.cookieClient.uploadDecal(fileContent, displayName, description || "");
           return {
@@ -17928,8 +18968,8 @@ var init_tools = __esm({
       async getSceneSummary(instancePath, topN, instance_id) {
         return this.sceneReadTools.getSceneSummary(instancePath, topN, instance_id);
       }
-      async applyMutationPlan(operations, dryRun, confirm, instance_id) {
-        return this.mutationTools.applyMutationPlan(operations, dryRun, confirm, instance_id);
+      async applyMutationPlan(operations, dryRun, confirm, instance_id, atomic) {
+        return this.mutationTools.applyMutationPlan(operations, dryRun, confirm, instance_id, atomic);
       }
       // Recipes: proven idempotent build macros. list is pure; apply runs the recipe's
       // Luau (creates/replaces named instances).
@@ -17976,7 +19016,7 @@ var init_tools = __esm({
       // state is this and how did it get here". Also readable at roblox://repro/bundle.
       // Track G2. ponytail: composes existing readers; no new persistence.
       async getReproductionBundle(instance_id) {
-        const parse = (r) => {
+        const parse2 = (r) => {
           try {
             const t = r?.content?.[0]?.text;
             return typeof t === "string" ? JSON.parse(t) : {};
@@ -17985,10 +19025,10 @@ var init_tools = __esm({
           }
         };
         const [snapshot, recentOperations, instances, episodes] = await Promise.all([
-          this.getWorldSnapshot(void 0, "overview", void 0, instance_id).then(parse).catch(() => ({})),
-          Promise.resolve(this.getOperationHistory(25)).then(parse).catch(() => ({})),
-          Promise.resolve(this.getConnectedInstances()).then(parse).catch(() => ({})),
-          Promise.resolve(this.listEpisodes()).then(parse).catch(() => ({}))
+          this.getWorldSnapshot(void 0, "overview", void 0, instance_id).then(parse2).catch(() => ({})),
+          Promise.resolve(this.getOperationHistory(25)).then(parse2).catch(() => ({})),
+          Promise.resolve(this.getConnectedInstances()).then(parse2).catch(() => ({})),
+          Promise.resolve(this.listEpisodes()).then(parse2).catch(() => ({}))
         ]);
         return { content: [{ type: "text", text: JSON.stringify({
           generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18008,17 +19048,17 @@ var init_tools = __esm({
       async toolCatalogSearch(body) {
         return this.discoveryTools.toolCatalogSearch(body);
       }
-      async getWorldSnapshot(path8, level, topNPerClass, instance_id) {
-        return this.worldTools.getWorldSnapshot(path8, level, topNPerClass, instance_id);
+      async getWorldSnapshot(path10, level, topNPerClass, instance_id) {
+        return this.worldTools.getWorldSnapshot(path10, level, topNPerClass, instance_id);
       }
-      async sceneSearch(query, path8, limit, instance_id) {
-        return this.worldTools.sceneSearch(query, path8, limit, instance_id);
+      async sceneSearch(query, path10, limit, instance_id) {
+        return this.worldTools.sceneSearch(query, path10, limit, instance_id);
       }
       async getNodeBatch(paths, fields, includeChildrenCount, instance_id) {
         return this.worldTools.getNodeBatch(paths, fields, includeChildrenCount, instance_id);
       }
-      async getChangesSince(snapshotId, path8, instance_id) {
-        return this.worldTools.getChangesSince(snapshotId, path8, instance_id);
+      async getChangesSince(snapshotId, path10, instance_id) {
+        return this.worldTools.getChangesSince(snapshotId, path10, instance_id);
       }
       async assetPreflightInsert(assetId, instance_id) {
         return this.worldTools.assetPreflightInsert(assetId, instance_id);
@@ -18057,10 +19097,10 @@ var init_tools = __esm({
           return { content: [{ type: "text", text: JSON.stringify({ error: "plugin returned no base64 payload" }) }] };
         }
         const bytes = Buffer.from(response.base64, "base64");
-        const resolved = path6.resolve(outputPath);
+        const resolved = path8.resolve(outputPath);
         try {
-          fs5.mkdirSync(path6.dirname(resolved), { recursive: true });
-          fs5.writeFileSync(resolved, bytes);
+          fs7.mkdirSync(path8.dirname(resolved), { recursive: true });
+          fs7.writeFileSync(resolved, bytes);
         } catch (err) {
           return { content: [{ type: "text", text: JSON.stringify({ error: `failed to write ${resolved}: ${err.message}` }) }] };
         }
@@ -18093,9 +19133,9 @@ var init_tools = __esm({
         let bytes;
         let sourceLabel;
         if (source.path !== void 0) {
-          const resolved = path6.resolve(source.path);
+          const resolved = path8.resolve(source.path);
           try {
-            bytes = fs5.readFileSync(resolved);
+            bytes = fs7.readFileSync(resolved);
           } catch (err) {
             return { content: [{ type: "text", text: JSON.stringify({ error: `failed to read ${resolved}: ${err.message}` }) }] };
           }
@@ -18288,7 +19328,7 @@ var init_tools = __esm({
               this.instanceManager.attachInstanceId(record, connected.instanceId);
               return wrapToolJsonText({ ...this.managedStatus(record), instance_id: connected.instanceId, connected: true });
             }
-            await new Promise((resolve6) => setTimeout(resolve6, 500));
+            await new Promise((resolve7) => setTimeout(resolve7, 500));
           }
         }
         return wrapToolJsonText({ ...this.managedStatus(record), connected: false });
@@ -18320,17 +19360,17 @@ var init_tools = __esm({
           const rawSnapshotBase64 = mutable.raw_snapshot_base64;
           if (typeof rawSnapshotBase64 === "string") {
             if (typeof outputPath === "string" && outputPath !== "") {
-              const resolvedOutputPath = path6.resolve(outputPath);
-              fs5.mkdirSync(path6.dirname(resolvedOutputPath), { recursive: true });
-              fs5.writeFileSync(resolvedOutputPath, Buffer.from(rawSnapshotBase64, "base64"));
+              const resolvedOutputPath = path8.resolve(outputPath);
+              fs7.mkdirSync(path8.dirname(resolvedOutputPath), { recursive: true });
+              fs7.writeFileSync(resolvedOutputPath, Buffer.from(rawSnapshotBase64, "base64"));
               mutable.output_path = resolvedOutputPath;
             }
             delete mutable.raw_snapshot_base64;
           }
           if (typeof summaryOutputPath === "string" && summaryOutputPath !== "") {
-            const resolvedSummaryPath = path6.resolve(summaryOutputPath);
-            fs5.mkdirSync(path6.dirname(resolvedSummaryPath), { recursive: true });
-            fs5.writeFileSync(resolvedSummaryPath, JSON.stringify(mutable, null, 2), "utf8");
+            const resolvedSummaryPath = path8.resolve(summaryOutputPath);
+            fs7.mkdirSync(path8.dirname(resolvedSummaryPath), { recursive: true });
+            fs7.writeFileSync(resolvedSummaryPath, JSON.stringify(mutable, null, 2), "utf8");
             mutable.summary_output_path = resolvedSummaryPath;
           }
           const baselineCapture = loadMicroProfilerBaseline(request.baseline, request.baseline_path);
@@ -18363,12 +19403,11 @@ var init_proxy_bridge_service = __esm({
     ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
       primaryBaseUrl;
       proxyInstanceId;
-      proxyRequestTimeout = 3e4;
       cachedInstances = [];
       refreshTimer;
       static REFRESH_INTERVAL_MS = 1e3;
       constructor(primaryBaseUrl) {
-        super();
+        super("");
         this.primaryBaseUrl = primaryBaseUrl;
         this.proxyInstanceId = randomUUID3();
         this.refreshInstances();
@@ -18399,7 +19438,7 @@ var init_proxy_bridge_service = __esm({
       }
       async sendRequest(endpoint, data, targetInstanceId, targetRole) {
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.proxyRequestTimeout);
+        const timeoutId = setTimeout(() => controller.abort(), resolveRequestTimeout(endpoint, this.requestTimeout));
         try {
           const response = await fetch(`${this.primaryBaseUrl}/proxy`, {
             method: "POST",
@@ -18415,8 +19454,11 @@ var init_proxy_bridge_service = __esm({
           });
           clearTimeout(timeoutId);
           if (!response.ok) {
-            const body = await response.text();
-            throw new Error(`Proxy request failed (${response.status}): ${body}`);
+            const body = await response.json().catch(() => void 0);
+            if (body?.outcome === "unknown" && body.requestId) {
+              throw new RequestOutcomeUnknownError(body.requestId, endpoint, resolveRequestTimeout(endpoint, this.requestTimeout));
+            }
+            throw new Error(`Proxy request failed (${response.status}): ${body?.error ?? "Unknown error"}`);
           }
           const result = await response.json();
           if (result.error) {
@@ -18431,6 +19473,26 @@ var init_proxy_bridge_service = __esm({
           throw err;
         }
       }
+      async lookupRequestStatus(requestId) {
+        try {
+          const response = await fetch(`${this.primaryBaseUrl}/request/${encodeURIComponent(requestId)}/status`);
+          if (response.status === 404)
+            return void 0;
+          if (!response.ok)
+            throw new Error(`Request status lookup failed (${response.status})`);
+          return response.json();
+        } catch {
+          return void 0;
+        }
+      }
+      async requestCancellation(requestId) {
+        const response = await fetch(`${this.primaryBaseUrl}/cancel`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ requestId })
+        });
+        return response.ok;
+      }
       cleanupOldRequests() {
       }
       clearAllPendingRequests() {
@@ -18662,6 +19724,12 @@ var init_setup_registry = __esm({
 import { Server as Server2 } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema as CallToolRequestSchema2, ErrorCode as ErrorCode2, ListToolsRequestSchema as ListToolsRequestSchema2, ListResourcesRequestSchema as ListResourcesRequestSchema2, ListResourceTemplatesRequestSchema as ListResourceTemplatesRequestSchema2, ReadResourceRequestSchema as ReadResourceRequestSchema2, SubscribeRequestSchema as SubscribeRequestSchema2, UnsubscribeRequestSchema as UnsubscribeRequestSchema2, McpError as McpError2 } from "@modelcontextprotocol/sdk/types.js";
+function resolveBridgeHost(host = process.env.ROBLOX_STUDIO_HOST) {
+  return host?.trim() || "127.0.0.1";
+}
+function isLoopbackHost(host) {
+  return host === "127.0.0.1" || host === "::1" || host === "localhost";
+}
 function shouldUseLazyToolLoading(value) {
   const flag = (value ?? "").trim().toLowerCase();
   return !(flag === "0" || flag === "false" || flag === "off");
@@ -18696,6 +19764,7 @@ var init_server = __esm({
     init_structured_output();
     init_server_instructions();
     init_resources();
+    init_capability_policy();
     BloxForgeServer = class {
       server;
       tools;
@@ -18712,8 +19781,10 @@ var init_server = __esm({
       lazyTools;
       activeToolNames;
       registry;
+      stdioCapabilities;
       constructor(config) {
         this.config = config;
+        this.stdioCapabilities = parseCapabilities(process.env.BLOXFORGE_STDIO_CAPABILITIES);
         this.allowedToolNames = new Set(config.tools.map((t) => t.name));
         this.lazyTools = shouldUseLazyToolLoading(process.env.ROBLOX_MCP_LAZY_TOOLS);
         this.activeToolNames = new Set(CORE_TOOLS);
@@ -18731,7 +19802,7 @@ var init_server = __esm({
           },
           instructions: SERVER_INSTRUCTIONS
         });
-        this.bridge = new BridgeService();
+        this.bridge = new BridgeService("");
         this.tools = new RobloxStudioTools(this.bridge);
         this.registry = new ToolRegistry();
         registerContractedTools(this.registry, this.tools);
@@ -18778,6 +19849,11 @@ var init_server = __esm({
           if (!this.allowedToolNames.has(name)) {
             throw new McpError2(ErrorCode2.MethodNotFound, `Unknown tool: ${name}`);
           }
+          const definition = this.config.tools.find((tool) => tool.name === name);
+          const capability = definition ? requiredCapability(name, definition.category) : void 0;
+          if (capability && this.stdioCapabilities && !this.stdioCapabilities.has(capability)) {
+            throw new McpError2(ErrorCode2.InvalidRequest, `Capability required: ${capability}`);
+          }
           try {
             const registryResult = await this.registry.callTool(name, this.tools, args ?? {});
             if (registryResult !== null && registryResult !== void 0) {
@@ -18862,7 +19938,10 @@ var init_server = __esm({
       }
       async run() {
         const basePort = process.env.ROBLOX_STUDIO_PORT ? parseInt(process.env.ROBLOX_STUDIO_PORT) : 58741;
-        const host = process.env.ROBLOX_STUDIO_HOST || "0.0.0.0";
+        const host = resolveBridgeHost();
+        if (!isLoopbackHost(host)) {
+          console.error(`[security] Bridge is listening on ${host}. This explicit non-loopback mode exposes unauthenticated local-control endpoints.`);
+        }
         let bridgeMode = "primary";
         let httpHandle;
         let primaryApp;
@@ -18872,6 +19951,7 @@ var init_server = __esm({
           primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config, this.registry);
           const result = await listenWithRetry(primaryApp, host, basePort, 1);
           httpHandle = result.server;
+          this.bridge.enableJournal();
           boundPort = result.port;
           console.error(`HTTP server listening on ${host}:${boundPort} for Studio plugin (primary mode)`);
           console.error(`Streamable HTTP MCP endpoint: http://localhost:${boundPort}/mcp`);
@@ -18884,12 +19964,13 @@ var init_server = __esm({
           console.error(`Port ${basePort} in use - entering proxy mode (forwarding to localhost:${basePort})`);
           const promotionIntervalMs = parseInt(process.env.ROBLOX_STUDIO_PROXY_PROMOTION_INTERVAL_MS || "5000");
           promotionInterval = setInterval(async () => {
-            const candidateBridge = new BridgeService();
+            const candidateBridge = new BridgeService("");
             const candidateTools = new RobloxStudioTools(candidateBridge);
             const candidateApp = createHttpServer(candidateTools, candidateBridge, this.allowedToolNames, this.config);
             try {
               const result = await listenWithRetry(candidateApp, host, basePort, 1);
               const oldBridge = this.bridge;
+              candidateBridge.enableJournal();
               this.bridge = candidateBridge;
               this.tools = candidateTools;
               if (oldBridge instanceof ProxyBridgeService) {
@@ -18951,7 +20032,18 @@ var init_server = __esm({
           this.bridge.cleanupOldRequests();
           this.bridge.cleanupStaleInstances();
         }, 5e3);
+        let shuttingDown = false;
+        const closeHttp = (handle) => new Promise((resolve7) => {
+          if (!handle) {
+            resolve7();
+            return;
+          }
+          handle.close(() => resolve7());
+        });
         const shutdown = async () => {
+          if (shuttingDown)
+            return;
+          shuttingDown = true;
           console.error("Shutting down MCP server...");
           clearInterval(activityInterval);
           clearInterval(cleanupInterval);
@@ -18960,12 +20052,14 @@ var init_server = __esm({
           if (this.bridge instanceof ProxyBridgeService) {
             this.bridge.stop();
           }
+          if (primaryApp)
+            primaryApp.setMCPServerActive(false);
+          if (legacyApp)
+            legacyApp.setMCPServerActive(false);
+          this.bridge.clearAllPendingRequests();
           await this.server.close().catch(() => {
           });
-          if (httpHandle)
-            httpHandle.close();
-          if (legacyHandle)
-            legacyHandle.close();
+          await Promise.all([closeHttp(httpHandle), closeHttp(legacyHandle)]);
           process.exit(0);
         };
         process.on("SIGTERM", shutdown);
@@ -18978,16 +20072,23 @@ var init_server = __esm({
   }
 });
 
+// ../core/dist/protocol-manifest.js
+var init_protocol_manifest = __esm({
+  "../core/dist/protocol-manifest.js"() {
+    "use strict";
+  }
+});
+
 // ../core/dist/install-plugin-helpers.js
-import { existsSync as existsSync4, readFileSync as readFileSync6, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync8, unlinkSync as unlinkSync2 } from "fs";
 import { execSync } from "child_process";
-import { join as join6 } from "path";
-import { homedir as homedir5 } from "os";
+import { join as join8 } from "path";
+import { homedir as homedir6 } from "os";
 function isWSL() {
   if (process.platform !== "linux")
     return false;
   try {
-    const v = readFileSync6("/proc/version", "utf8");
+    const v = readFileSync8("/proc/version", "utf8");
     return /microsoft|wsl/i.test(v);
   } catch {
     return false;
@@ -19005,7 +20106,7 @@ function getWindowsUserPluginsDir() {
     }).toString().trim();
     if (!linuxPath)
       return null;
-    return join6(linuxPath, "Roblox", "Plugins");
+    return join8(linuxPath, "Roblox", "Plugins");
   } catch {
     return null;
   }
@@ -19014,7 +20115,7 @@ function getPluginsFolder() {
   if (process.env.MCP_PLUGINS_DIR)
     return process.env.MCP_PLUGINS_DIR;
   if (process.platform === "win32") {
-    return join6(process.env.LOCALAPPDATA || join6(homedir5(), "AppData", "Local"), "Roblox", "Plugins");
+    return join8(process.env.LOCALAPPDATA || join8(homedir6(), "AppData", "Local"), "Roblox", "Plugins");
   }
   if (isWSL()) {
     const win = getWindowsUserPluginsDir();
@@ -19022,11 +20123,11 @@ function getPluginsFolder() {
       return win;
     console.warn("[install-plugin] WSL detected but could not resolve Windows %LOCALAPPDATA%. Falling back to ~/Documents/Roblox/Plugins/ - you will likely need to copy the rbxmx to /mnt/c/Users/<you>/AppData/Local/Roblox/Plugins/ manually. Set MCP_PLUGINS_DIR to skip detection.");
   }
-  return join6(homedir5(), "Documents", "Roblox", "Plugins");
+  return join8(homedir6(), "Documents", "Roblox", "Plugins");
 }
 function handleVariantConflict({ pluginsFolder, otherAssetName, replace, log = console.log, warn = console.warn }) {
-  const otherDest = join6(pluginsFolder, otherAssetName);
-  if (!existsSync4(otherDest))
+  const otherDest = join8(pluginsFolder, otherAssetName);
+  if (!existsSync7(otherDest))
     return;
   if (replace) {
     try {
@@ -19050,20 +20151,43 @@ var init_install_plugin_helpers = __esm({
 });
 
 // ../core/dist/doctor.js
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
+import * as os7 from "os";
 function checkNodeVersion(version) {
   const major = parseInt(version.replace(/^v/, "").split(".")[0] ?? "0", 10);
   if (Number.isNaN(major) || major < 18) {
-    return { name: "Node version", status: "fail", detail: `${version} \u2014 Node 18+ is required.` };
+    return {
+      name: "Node version",
+      status: "fail",
+      detail: `${version} \u2014 Node 18+ is required.`,
+      actionable: {
+        fix: "Upgrade Node.js to version 18 or newer.",
+        verify: 'Run "node -v" to verify your version, then run "npx @princeofscale/bloxforge verify".'
+      }
+    };
   }
   return { name: "Node version", status: "ok", detail: version };
 }
 function formatDoctorReport(checks) {
-  const lines = checks.map((c) => `  ${SYMBOL[c.status]} ${c.name}: ${c.detail}`);
+  const lines = [];
+  for (const c of checks) {
+    lines.push(`  ${SYMBOL[c.status]} ${c.name}: ${c.detail}`);
+    if (c.status !== "ok" && c.actionable) {
+      lines.push(`      Fix: ${c.actionable.fix}`);
+      if (c.actionable.verify) {
+        lines.push(`      Verify: ${c.actionable.verify}`);
+      }
+    }
+  }
   const worst = checks.some((c) => c.status === "fail") ? "fail" : checks.some((c) => c.status === "warn") ? "warn" : "ok";
   const summary = worst === "ok" ? "All checks passed." : worst === "warn" ? "Some checks need attention (warnings)." : "Problems found \u2014 see failures above.";
-  return ["bloxforge doctor", ...lines, "", summary].join("\n");
+  return ["bloxforge doctor / verify", ...lines, "", summary].join("\n");
+}
+function fetchHealth(fetchImpl, port) {
+  return fetchImpl(`http://localhost:${port}/health`, {
+    signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS)
+  });
 }
 async function collectDoctorChecks(options = {}) {
   const checks = [];
@@ -19076,42 +20200,94 @@ async function collectDoctorChecks(options = {}) {
   try {
     const folder = getPluginsFolder();
     const variants = ["MCPPlugin.rbxmx", "MCPInspectorPlugin.rbxmx"];
-    const found = variants.filter((v) => fs6.existsSync(path7.join(folder, v)));
-    checks.push(found.length > 0 ? { name: "Studio plugin installed", status: "ok", detail: `${found.join(", ")} in ${folder}` } : { name: "Studio plugin installed", status: "warn", detail: `none found in ${folder}. Run with --install-plugin.` });
+    const found = variants.filter((v) => fs8.existsSync(path9.join(folder, v)));
+    checks.push(found.length > 0 ? { name: "Studio plugin installed", status: "ok", detail: `${found.join(", ")} in ${folder}` } : {
+      name: "Studio plugin installed",
+      status: "warn",
+      detail: `none found in ${folder}. Run with --install-plugin.`,
+      actionable: {
+        fix: 'Run "npx @princeofscale/bloxforge --install-plugin" to install the plugin to your local Roblox directory.',
+        verify: 'Run "npx @princeofscale/bloxforge verify" again to confirm installation.'
+      }
+    });
   } catch (error) {
-    checks.push({ name: "Studio plugin installed", status: "warn", detail: `could not resolve plugins folder: ${error instanceof Error ? error.message : String(error)}` });
+    checks.push({
+      name: "Studio plugin installed",
+      status: "warn",
+      detail: `could not resolve plugins folder: ${error instanceof Error ? error.message : String(error)}`,
+      actionable: {
+        fix: "Ensure your Roblox Studio installation is valid and accessible.",
+        verify: "Check if Roblox Studio opens correctly, then try again."
+      }
+    });
   }
   const port = options.port ?? (process.env.ROBLOX_STUDIO_PORT ? parseInt(process.env.ROBLOX_STUDIO_PORT) : 58741);
   const doFetch = options.fetchImpl ?? fetch;
   try {
-    const res = await doFetch(`http://localhost:${port}/health`);
+    const res = await fetchHealth(doFetch, port);
     if (res.ok) {
       const health = await res.json();
       checks.push({ name: "Local bridge running", status: "ok", detail: `responding on port ${port}` });
-      checks.push(health.pluginConnected ? { name: "Studio reachable", status: "ok", detail: `${health.instanceCount ?? 0} place(s) connected` } : { name: "Studio reachable", status: "warn", detail: "bridge up but no Studio plugin connected. Open Studio and enable Allow HTTP Requests." });
+      checks.push(health.pluginConnected ? { name: "Studio reachable", status: "ok", detail: `${health.instanceCount ?? 0} place(s) connected` } : {
+        name: "Studio reachable",
+        status: "warn",
+        detail: "bridge up but no Studio plugin connected.",
+        actionable: {
+          fix: 'Open Roblox Studio, open your place, and ensure "Allow HTTP Requests" is enabled in Game Settings -> Security. Play or Run the game.',
+          verify: 'Ensure the BloxForge plugin shows "Connected" in Studio, then run verify again.'
+        }
+      });
       checks.push({
         name: "Lazy tool loading",
         status: health.lazyTools === false ? "warn" : "ok",
         detail: health.lazyTools === false ? "disabled via ROBLOX_MCP_LAZY_TOOLS opt-out; all schemas are advertised upfront" : `default path active (${health.activeToolCount ?? 0} active tools; loaded ${health.loadedToolsets?.join(", ") || "core"})`
       });
       const first = health.instances?.[0];
-      if (first) {
+      const versionInstance = health.instances?.find((instance) => instance.versionMismatch) ?? first;
+      const protocolInstance = health.instances?.find((instance) => instance.protocolMismatch) ?? first;
+      if (versionInstance) {
         checks.push({
           name: "Studio plugin version",
-          status: health.versionMismatch || first.versionMismatch ? "warn" : "ok",
-          detail: `plugin v${first.pluginVersion ?? "unknown"} (${first.pluginVariant ?? "unknown"}), server v${health.serverVersion ?? health.version ?? options.version ?? "unknown"}`
+          status: health.versionMismatch || versionInstance.versionMismatch ? "warn" : "ok",
+          detail: `plugin v${versionInstance.pluginVersion ?? "unknown"} (${versionInstance.pluginVariant ?? "unknown"}), server v${health.serverVersion ?? health.version ?? options.version ?? "unknown"}`,
+          actionable: health.versionMismatch || versionInstance.versionMismatch ? {
+            fix: 'Run "npx @princeofscale/bloxforge --install-plugin" to synchronize the plugin version with your local server.',
+            verify: 'Restart Roblox Studio, then run "npx @princeofscale/bloxforge verify" and confirm this check passes.'
+          } : void 0
         });
+      }
+      if (protocolInstance) {
         checks.push({
           name: "Protocol version",
-          status: health.protocolMismatch || first.protocolMismatch ? "warn" : "ok",
-          detail: `plugin protocol ${first.pluginProtocolVersion ?? "unknown"}, server protocol ${first.serverProtocolVersion ?? health.protocolVersion ?? "unknown"}`
+          status: health.protocolMismatch || protocolInstance.protocolMismatch ? "warn" : "ok",
+          detail: `plugin protocol ${protocolInstance.pluginProtocolVersion ?? "unknown"}, server protocol ${protocolInstance.serverProtocolVersion ?? health.protocolVersion ?? "unknown"}`,
+          actionable: health.protocolMismatch || protocolInstance.protocolMismatch ? {
+            fix: "Your server and plugin are using incompatible communication protocols. Please update both to the latest versions.",
+            verify: 'Restart Roblox Studio, then run "npx @princeofscale/bloxforge verify" and confirm both protocol versions match.'
+          } : void 0
         });
       }
     } else {
-      checks.push({ name: "Local bridge running", status: "fail", detail: `port ${port} responded ${res.status}` });
+      checks.push({
+        name: "Local bridge running",
+        status: "fail",
+        detail: `port ${port} responded ${res.status}`,
+        actionable: {
+          fix: `Another application might be using port ${port}. Try running the server on a different port using --port <number>.`,
+          verify: 'Run "npx @princeofscale/bloxforge verify --port <number>" on the new port and confirm this check passes.'
+        }
+      });
     }
   } catch {
-    checks.push({ name: "Local bridge running", status: "warn", detail: `nothing responding on port ${port}. The bridge only runs while the MCP server is started by your client.` });
+    checks.push({
+      name: "Local bridge running",
+      status: "warn",
+      detail: `nothing responding on port ${port}. The bridge only runs while the MCP server is started.`,
+      actionable: {
+        fix: 'Start the BloxForge server in another terminal (e.g., via "npx @princeofscale/bloxforge") before running diagnostics.',
+        verify: 'Keep the server running, then in a new terminal run "npx @princeofscale/bloxforge verify".'
+      }
+    });
   }
   return checks;
 }
@@ -19120,12 +20296,85 @@ async function runDoctor(options = {}) {
   console.log(formatDoctorReport(checks));
   return checks.some((c) => c.status === "fail") ? 1 : 0;
 }
-var SYMBOL;
+async function generateDiagnosticReport(options = {}) {
+  const checks = await collectDoctorChecks(options);
+  const home = os7.homedir();
+  const sanitize = (text) => {
+    const escapedHome = home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return text.replace(new RegExp(escapedHome, "g"), "<home>");
+  };
+  const lines = [];
+  lines.push("==================================================");
+  lines.push("            BLOXFORGE DIAGNOSTIC REPORT           ");
+  lines.push("==================================================");
+  lines.push("");
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`OS: ${process.platform} (${os7.type()} ${os7.release()} ${os7.arch()})`);
+  lines.push(`Node Version: ${process.version}`);
+  lines.push(`BloxForge Version: ${options.version ?? "unknown"}`);
+  lines.push(`Protocol Version: ${MCP_PROTOCOL_VERSION}`);
+  lines.push(`Selected Profile: ${process.env.BLOXFORGE_TOOL_PROFILE || "core"}`);
+  lines.push("");
+  lines.push("--- Doctor Results ---");
+  for (const c of checks) {
+    const statusSymbol = c.status === "ok" ? "[ OK ]" : c.status === "warn" ? "[WARN]" : "[FAIL]";
+    lines.push(`${statusSymbol} ${c.name}: ${sanitize(c.detail)}`);
+  }
+  lines.push("");
+  const port = options.port ?? (process.env.ROBLOX_STUDIO_PORT ? parseInt(process.env.ROBLOX_STUDIO_PORT) : 58741);
+  const doFetch = options.fetchImpl ?? fetch;
+  try {
+    const res = await fetchHealth(doFetch, port);
+    if (res.ok) {
+      const health = await res.json();
+      lines.push("--- Running Server Status ---");
+      lines.push(`Server Uptime: ${Math.round((health.uptime ?? 0) / 1e3)}s`);
+      lines.push(`Lazy Tools Enabled: ${health.lazyTools ?? "unknown"}`);
+      lines.push(`Active Tool Count: ${health.activeToolCount ?? "unknown"}`);
+      lines.push(`Loaded Toolsets: ${health.loadedToolsets?.join(", ") ?? "none"}`);
+      lines.push(`Connected Instances: ${health.instanceCount ?? 0}`);
+      if (health.instances && health.instances.length > 0) {
+        for (const inst of health.instances) {
+          lines.push(`  - Instance: ${inst.role} (variant: ${inst.pluginVariant ?? "unknown"}, version: ${inst.pluginVersion ?? "unknown"}, protocol: ${inst.pluginProtocolVersion ?? "unknown"})`);
+        }
+      }
+      lines.push("");
+      if (health.recentDisconnects && health.recentDisconnects.length > 0) {
+        lines.push("--- Recent Disconnects ---");
+        for (const disc of health.recentDisconnects) {
+          lines.push(`  - [${new Date(disc.disconnectedAt).toISOString()}] role: ${disc.role}, reason: ${disc.reason}`);
+        }
+        lines.push("");
+      }
+      if (health.session) {
+        lines.push("--- Session Summary ---");
+        lines.push(`Total Calls: ${health.session.totalCalls ?? 0}`);
+        lines.push(`Failed Calls: ${health.session.failures ?? 0}`);
+        if (health.session.byTool) {
+          for (const stats of health.session.byTool) {
+            lines.push(`  - ${stats.toolName}: ${stats.calls} calls, ${stats.failures} failures, avg ${Math.round(stats.averageDurationMs ?? 0)}ms`);
+          }
+        }
+        lines.push("");
+      }
+    }
+  } catch {
+    lines.push("--- Running Server Status ---");
+    lines.push("MCP server is not currently running on this port.");
+    lines.push("");
+  }
+  lines.push("==================================================");
+  lines.push("End of Report");
+  return lines.join("\n");
+}
+var SYMBOL, HEALTH_TIMEOUT_MS;
 var init_doctor = __esm({
   "../core/dist/doctor.js"() {
     "use strict";
     init_install_plugin_helpers();
+    init_bridge_service();
     SYMBOL = { ok: "\u2713", warn: "!", fail: "\u2717" };
+    HEALTH_TIMEOUT_MS = 3e3;
   }
 });
 
@@ -19134,8 +20383,11 @@ var init_dist = __esm({
   "../core/dist/index.js"() {
     "use strict";
     init_server();
+    init_server();
     init_http_server();
     init_bridge_service();
+    init_protocol_manifest();
+    init_quality_tools();
     init_tools();
     init_studio_client();
     init_definitions();
@@ -19153,13 +20405,13 @@ __export(install_plugin_exports, {
   installBundledPlugin: () => installBundledPlugin,
   installPlugin: () => installPlugin
 });
-import { copyFileSync as copyFileSync2, createWriteStream, existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync7, unlinkSync as unlinkSync3 } from "fs";
-import { dirname as dirname6, join as join8 } from "path";
+import { copyFileSync as copyFileSync3, createWriteStream, existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync9, unlinkSync as unlinkSync3 } from "fs";
+import { dirname as dirname8, join as join10 } from "path";
 import { fileURLToPath } from "url";
 import { get } from "https";
 function httpsGet(url) {
-  return new Promise((resolve6, reject) => {
-    const req = get(url, { headers: { "User-Agent": "bloxforge" } }, resolve6);
+  return new Promise((resolve7, reject) => {
+    const req = get(url, { headers: { "User-Agent": "bloxforge" } }, resolve7);
     req.on("error", reject);
     req.setTimeout(TIMEOUT_MS, () => {
       req.destroy(new Error(`Request timed out after ${TIMEOUT_MS}ms`));
@@ -19177,7 +20429,7 @@ async function download(url, dest, redirects = 0) {
   if (res.statusCode !== 200) {
     throw new Error(`Download failed: HTTP ${res.statusCode}`);
   }
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const file = createWriteStream(dest);
     const cleanup = (err) => {
       file.close(() => {
@@ -19191,7 +20443,7 @@ async function download(url, dest, redirects = 0) {
     res.pipe(file);
     file.on("finish", () => {
       file.close();
-      resolve6();
+      resolve7();
     });
     file.on("error", cleanup);
     res.on("error", cleanup);
@@ -19224,8 +20476,8 @@ function prepareInstall({
   warn
 }) {
   const pluginsFolder = getPluginsFolder();
-  if (!existsSync6(pluginsFolder)) {
-    mkdirSync7(pluginsFolder, { recursive: true });
+  if (!existsSync9(pluginsFolder)) {
+    mkdirSync8(pluginsFolder, { recursive: true });
   }
   handleVariantConflict({
     pluginsFolder,
@@ -19237,23 +20489,23 @@ function prepareInstall({
   return pluginsFolder;
 }
 function bundledAssetPath() {
-  const currentDir = dirname6(fileURLToPath(import.meta.url));
+  const currentDir = dirname8(fileURLToPath(import.meta.url));
   const candidates = [
-    join8(currentDir, "..", "studio-plugin", ASSET_NAME),
-    join8(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
+    join10(currentDir, "..", "studio-plugin", ASSET_NAME),
+    join10(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
   ];
-  return candidates.find((candidate) => existsSync6(candidate)) ?? null;
+  return candidates.find((candidate) => existsSync9(candidate)) ?? null;
 }
 function packageVersion() {
-  const currentDir = dirname6(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync7(join8(currentDir, "..", "package.json"), "utf8"));
+  const currentDir = dirname8(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync9(join10(currentDir, "..", "package.json"), "utf8"));
   if (!pkg.version) {
     throw new Error("Package version not found");
   }
   return pkg.version;
 }
 function bundledPluginVersion(source) {
-  const match = readFileSync7(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
+  const match = readFileSync9(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
   return match ? match[1] : null;
 }
 function assertBundledPluginVersion(source) {
@@ -19266,9 +20518,9 @@ function assertBundledPluginVersion(source) {
   }
 }
 function filesMatch(a, b) {
-  if (!existsSync6(b)) return false;
-  const aBytes = readFileSync7(a);
-  const bBytes = readFileSync7(b);
+  if (!existsSync9(b)) return false;
+  const aBytes = readFileSync9(a);
+  const bBytes = readFileSync9(b);
   return aBytes.length === bBytes.length && aBytes.equals(bBytes);
 }
 async function installBundledPlugin(options = {}) {
@@ -19281,9 +20533,9 @@ async function installBundledPlugin(options = {}) {
   }
   assertBundledPluginVersion(source);
   const pluginsFolder = prepareInstall({ replaceVariant, log, warn });
-  const dest = join8(pluginsFolder, ASSET_NAME);
+  const dest = join10(pluginsFolder, ASSET_NAME);
   if (filesMatch(source, dest)) return;
-  copyFileSync2(source, dest);
+  copyFileSync3(source, dest);
   log(`Installed ${ASSET_NAME} to ${dest}`);
 }
 async function installPlugin(options = {}) {
@@ -19295,23 +20547,23 @@ async function installPlugin(options = {}) {
   const bundled = bundledAssetPath();
   if (bundled) {
     assertBundledPluginVersion(bundled);
-    const dest2 = join8(pluginsFolder, ASSET_NAME);
+    const dest2 = join10(pluginsFolder, ASSET_NAME);
     if (filesMatch(bundled, dest2)) {
       log(`${ASSET_NAME} already installed.`);
       return;
     }
-    copyFileSync2(bundled, dest2);
+    copyFileSync3(bundled, dest2);
     log(`Installed bundled ${ASSET_NAME} to ${dest2}`);
     return;
   }
   log(dev ? "Fetching latest dev prerelease..." : "Fetching latest release...");
-  const release = dev ? await findDevRelease() : await fetchJson(`https://api.github.com/repos/${REPO}/releases/latest`);
-  const asset = release.assets?.find((a) => a.name === ASSET_NAME);
+  const release2 = dev ? await findDevRelease() : await fetchJson(`https://api.github.com/repos/${REPO}/releases/latest`);
+  const asset = release2.assets?.find((a) => a.name === ASSET_NAME);
   if (!asset) {
-    throw new Error(`${ASSET_NAME} not found in release ${release.tag_name}`);
+    throw new Error(`${ASSET_NAME} not found in release ${release2.tag_name}`);
   }
-  const dest = join8(pluginsFolder, ASSET_NAME);
-  log(`Downloading ${ASSET_NAME} from ${release.tag_name}...`);
+  const dest = join10(pluginsFolder, ASSET_NAME);
+  log(`Downloading ${ASSET_NAME} from ${release2.tag_name}...`);
   await download(asset.browser_download_url, dest);
   log(`Installed to ${dest}`);
 }
@@ -19337,18 +20589,62 @@ var argFlagValue = (flag) => {
 };
 var portArg = argFlagValue("--port");
 if (portArg) process.env.ROBLOX_STUDIO_PORT = portArg;
+var hostArg = argFlagValue("--host");
+if (hostArg) process.env.ROBLOX_STUDIO_HOST = hostArg;
+var sessionTokenArg = argFlagValue("--session-token");
+if (sessionTokenArg) process.env.BLOXFORGE_SESSION_TOKEN = sessionTokenArg;
 if (process.argv.includes("--debug")) process.env.ROBLOX_STUDIO_DEBUG = "1";
-if (process.argv.includes("--doctor")) {
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+  console.log(`BloxForge MCP Server
+
+Usage:
+  npx @princeofscale/bloxforge [options]
+  npx @princeofscale/bloxforge <command>
+
+Options:
+  --port <port>                 Port to run the HTTP bridge on (default: 58741)
+  --host <host>                 Bind host (default: 127.0.0.1; non-loopback is unsafe)
+  --session-token <token>       Require bearer auth for /proxy and /mcp HTTP clients
+  --debug                       Enable debug logging (stack traces, verbose output)
+  --open-cloud-key <key>        Roblox Open Cloud API Key (for some advanced tools)
+  --pollinations-key <key>      Pollinations API Key (for image-generation tools)
+  --creator-id <id>             Roblox Creator User ID
+  --creator-group-id <id>       Roblox Creator Group ID
+  --profile <profile>           Load specific tool profile (e.g., core)
+  --help, -h                    Show this help message
+
+Commands:
+  verify, --doctor              Run diagnostics to verify installation and connection
+  report                        Generate a detailed diagnostic report for bug reports
+  --install-plugin              Manually install the Studio plugin to your local Roblox directory
+  --auto-install-plugin         Silently install the plugin (used by AI clients automatically)
+  `);
+  process.exit(0);
+}
+if (process.argv.includes("--doctor") || process.argv.includes("verify")) {
   const require2 = createRequire(import.meta.url);
   const { version } = require2("../package.json");
   process.exitCode = await runDoctor({
     version,
     port: portArg ? parseInt(portArg) : void 0
   });
+} else if (process.argv.includes("--report") || process.argv.includes("report")) {
+  const require2 = createRequire(import.meta.url);
+  const { version } = require2("../package.json");
+  const reportText = await generateDiagnosticReport({
+    version,
+    port: portArg ? parseInt(portArg) : void 0
+  });
+  console.log(reportText);
+  process.exit(0);
 } else if (process.argv.includes("--install-plugin")) {
   const { installPlugin: installPlugin2 } = await Promise.resolve().then(() => (init_install_plugin(), install_plugin_exports));
   await installPlugin2().catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
+    console.error(`[install-plugin] What happened: Failed to install plugin.`);
+    console.error(`[install-plugin] Why: ${err instanceof Error ? err.message : String(err)}`);
+    console.error(`[install-plugin] Fix: Ensure your Roblox Studio plugins folder is accessible and you have write permissions.`);
+    console.error(`[install-plugin] Verify: Run 'npx @princeofscale/bloxforge verify' to check if the plugin is installed.`);
+    if (process.env.ROBLOX_STUDIO_DEBUG) console.error(err);
     process.exitCode = 1;
   });
 } else {
@@ -19359,7 +20655,7 @@ if (process.argv.includes("--doctor")) {
       warn: (message) => console.error(message)
     }).catch((err) => {
       console.error(
-        `[install-plugin] Auto-install skipped: ${err instanceof Error ? err.message : String(err)}`
+        `[install-plugin] Auto-install skipped. Why: ${err instanceof Error ? err.message : String(err)}`
       );
     });
   }
@@ -19385,7 +20681,12 @@ if (process.argv.includes("--doctor")) {
     tools: getAllTools()
   });
   server.run().catch((error) => {
-    console.error("Server failed to start:", error);
+    console.error(`
+[Fatal Error] What happened: BloxForge Server failed to start.`);
+    console.error(`[Fatal Error] Why: ${error instanceof Error ? error.message : String(error)}`);
+    console.error(`[Fatal Error] Fix: Check if another instance is already running on port ${process.env.ROBLOX_STUDIO_PORT || 58741}.`);
+    console.error(`[Fatal Error] Verify: Run 'npx @princeofscale/bloxforge verify' to diagnose the issue.`);
+    if (process.env.ROBLOX_STUDIO_DEBUG) console.error(error);
     process.exit(1);
   });
 }