@impractical-ai/motion 0.1.13 → 0.1.14

package/dist/{stdio-PLWZDKDA.js → stdio-M2YRHGFJ.js}

@@ -1,23 +1,29 @@
 #!/usr/bin/env node
 import {
-  openBrowser
-} from "./chunk-ZCTJTQB7.js";
+  DEVICE_START_BODY,
+  fetchWorkspaces,
+  grantScope,
+  openBrowser,
+  workspaceLabel
+} from "./chunk-L5ERED5A.js";
 import {
   ApiError,
   admitMcpCall,
   invoke,
   invokeAt,
   loadConfig,
+  requireConfig,
   saveConfig,
+  studioQuery,
   validateApiResponse,
   withAdmissionReceipt
-} from "./chunk-GAHKKLF3.js";
+} from "./chunk-O3BUN66P.js";
 import {
   BUILD_COMMIT,
   PACKAGE_VERSION,
   PRODUCTION_APP_URL,
   PRODUCTION_SUPABASE_URL
-} from "./chunk-PTYSKJ2Y.js";
+} from "./chunk-7SNCVSTA.js";
 import {
   __commonJS,
   __export,
@@ -3100,9 +3106,28 @@ var require_utils = __commonJS({
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isPort = RegExp.prototype.test.bind(/^\d*$/u);
     var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
     var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+    var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+    var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+    var BYTE_HEX = new Array(256);
+    {
+      const HEX_DIGITS = "0123456789ABCDEF";
+      for (let i = 0; i < 256; i++) {
+        BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+      }
+    }
+    function percentEncodeNonAscii(cp) {
+      if (cp < 2048) {
+        return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+      }
+      if (cp < 65536) {
+        return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+      }
+      return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+    }
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -3127,91 +3152,105 @@ var require_utils = __commonJS({
       }
       return acc;
     }
+    var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+    var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+    var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
     var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-    function consumeIsZone(buffer) {
-      buffer.length = 0;
-      return true;
-    }
-    function consumeHextets(buffer, address, output) {
-      if (buffer.length) {
-        const hex3 = stringArrayToHexStripped(buffer);
-        if (hex3 !== "") {
-          address.push(hex3);
-        } else {
-          output.error = true;
-          return false;
+    function isZoneIdentifier(zone) {
+      if (zone.length === 0) return false;
+      for (let i = 0; i < zone.length; i++) {
+        if (isZoneCharacter(zone[i])) continue;
+        if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+          i += 2;
+          continue;
         }
-        buffer.length = 0;
+        return false;
       }
       return true;
     }
-    function getIPV6(input) {
-      let tokenCount = 0;
-      const output = { error: false, address: "", zone: "" };
-      const address = [];
-      const buffer = [];
-      let endipv6Encountered = false;
-      let endIpv6 = false;
-      let consume = consumeHextets;
-      for (let i = 0; i < input.length; i++) {
-        const cursor = input[i];
-        if (cursor === "[" || cursor === "]") {
-          continue;
-        }
-        if (cursor === ":") {
-          if (endipv6Encountered === true) {
-            endIpv6 = true;
-          }
-          if (!consume(buffer, address, output)) {
-            break;
-          }
-          if (++tokenCount > 7) {
-            output.error = true;
-            break;
-          }
-          if (i > 0 && input[i - 1] === ":") {
-            endipv6Encountered = true;
-          }
-          address.push(":");
-          continue;
-        } else if (cursor === "%") {
-          if (!consume(buffer, address, output)) {
-            break;
+    function compressIPv6ZeroRun(hextets) {
+      let bestStart = -1;
+      let bestLength = 0;
+      let runStart = -1;
+      let runLength = 0;
+      for (let i = 0; i < hextets.length; i++) {
+        if (hextets[i] === "0") {
+          if (runStart === -1) runStart = i;
+          runLength++;
+          if (runLength > bestLength) {
+            bestLength = runLength;
+            bestStart = runStart;
           }
-          consume = consumeIsZone;
         } else {
-          buffer.push(cursor);
+          runStart = -1;
+          runLength = 0;
+        }
+      }
+      if (bestLength < 2) return hextets.join(":");
+      const head = hextets.slice(0, bestStart).join(":");
+      const tail = hextets.slice(bestStart + bestLength).join(":");
+      return head + "::" + tail;
+    }
+    function normalizeIPv6Address(input) {
+      const compression = input.indexOf("::");
+      if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
+      const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+      const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+      if (compression !== -1) {
+        if (left.length === 1 && left[0] === "") left.length = 0;
+        if (right.length === 1 && right[0] === "") right.length = 0;
+      }
+      const parts = left.concat(right);
+      let hextetCount = 0;
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part === "") return void 0;
+        if (part.indexOf(".") !== -1) {
+          if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
+          hextetCount += 2;
           continue;
         }
+        if (!isHextet(part)) return void 0;
+        parts[i] = parseInt(part, 16).toString(16);
+        hextetCount++;
       }
-      if (buffer.length) {
-        if (consume === consumeIsZone) {
-          output.zone = buffer.join("");
-        } else if (endIpv6) {
-          address.push(buffer.join(""));
-        } else {
-          address.push(stringArrayToHexStripped(buffer));
-        }
+      if (compression === -1) {
+        if (hextetCount !== 8) return void 0;
+        return compressIPv6ZeroRun(parts);
       }
-      output.address = address.join("");
-      return output;
+      if (hextetCount >= 8) return void 0;
+      const expanded = parts.slice(0, left.length);
+      for (let i = hextetCount; i < 8; i++) expanded.push("0");
+      for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
+      return compressIPv6ZeroRun(expanded);
     }
     function normalizeIPv6(host) {
-      if (findToken(host, ":") < 2) {
-        return { host, isIPV6: false };
-      }
-      const ipv63 = getIPV6(host);
-      if (!ipv63.error) {
-        let newHost = ipv63.address;
-        let escapedHost = ipv63.address;
-        if (ipv63.zone) {
-          newHost += "%" + ipv63.zone;
-          escapedHost += "%25" + ipv63.zone;
-        }
-        return { host: newHost, isIPV6: true, escapedHost };
-      } else {
-        return { host, isIPV6: false };
-      }
+      const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+      const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+      if (hasBracket && !bracketed) return { host, isIPV6: false, error: true };
+      let input = bracketed ? host.slice(1, -1) : host;
+      if (bracketed && isIPvFuture(input)) {
+        input = input.toLowerCase();
+        return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+      }
+      if (findToken(input, ":") < 2) {
+        return { host, isIPV6: false, error: bracketed };
+      }
+      let zoneIdentifier = "";
+      const zoneSeparator = input.indexOf("%");
+      if (zoneSeparator !== -1) {
+        const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+        zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+        if (!isZoneIdentifier(zoneIdentifier)) return { host, isIPV6: false, error: true };
+        input = input.slice(0, zoneSeparator);
+      }
+      const address = normalizeIPv6Address(input);
+      if (address === void 0) return { host, isIPV6: false, error: true };
+      return {
+        host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+        escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+        isIPV6: true
+      };
     }
     function findToken(str, token) {
       let ind = 0;
@@ -3330,7 +3369,8 @@ var require_utils = __commonJS({
     function normalizePathEncoding(input) {
       let output = "";
       for (let i = 0; i < input.length; i++) {
-        if (input[i] === "%" && i + 2 < input.length) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
           const hex3 = input.slice(i + 1, i + 3);
           if (isHexPair(hex3)) {
             const normalizedHex = hex3.toUpperCase();
@@ -3344,10 +3384,152 @@ var require_utils = __commonJS({
             continue;
           }
         }
-        if (isPathCharacter(input[i])) {
-          output += input[i];
+        if (isPathCharacter(ch)) {
+          output += ch;
+        } else {
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function serializePathEncoding(input, pathNoScheme = false) {
+      let output = "";
+      let firstSegment = pathNoScheme && input[0] !== "/";
+      for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        if (ch === "/") {
+          firstSegment = false;
+        }
+        if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
+          output += ch;
+        } else {
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function encodeComponent(input, isAllowed) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        if (isAllowed(ch)) {
+          output += ch;
+        } else {
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function encodeUserinfo(input) {
+      return encodeComponent(input, isUserinfoCharacter);
+    }
+    function encodeQuery(input) {
+      return encodeComponent(input, isQueryFragmentCharacter);
+    }
+    function encodeFragment(input) {
+      return encodeComponent(input, isQueryFragmentCharacter);
+    }
+    function isEscapeSafe(cp) {
+      return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+    }
+    function normalizeQueryFragmentEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isQueryFragmentCharacter(ch)) {
+          output += ch;
         } else {
-          output += escape(input[i]);
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
         }
       }
       return output;
@@ -3370,14 +3552,18 @@ var require_utils = __commonJS({
     function recomposeAuthority(component) {
       const uriTokens = [];
       if (component.userinfo !== void 0) {
-        uriTokens.push(component.userinfo);
+        uriTokens.push(encodeUserinfo(component.userinfo));
         uriTokens.push("@");
       }
       if (component.host !== void 0) {
-        let host = unescape(component.host);
+        let host = component.host;
         if (!isIPv4(host)) {
-          const ipV6res = normalizeIPv6(host);
-          if (ipV6res.isIPV6 === true) {
+          let ipV6res = normalizeIPv6(host);
+          if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+            host = normalizePercentEncoding(host, true);
+            ipV6res = normalizeIPv6(host);
+          }
+          if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
             host = reescapeHostDelimiters(host, false);
@@ -3386,8 +3572,12 @@ var require_utils = __commonJS({
         uriTokens.push(host);
       }
       if (typeof component.port === "number" || typeof component.port === "string") {
+        const port = String(component.port);
+        if (!isPort(port)) {
+          throw new TypeError("URI port is malformed.");
+        }
         uriTokens.push(":");
-        uriTokens.push(String(component.port));
+        uriTokens.push(port);
       }
       return uriTokens.length ? uriTokens.join("") : void 0;
     }
@@ -3397,6 +3587,11 @@ var require_utils = __commonJS({
       reescapeHostDelimiters,
       normalizePercentEncoding,
       normalizePathEncoding,
+      serializePathEncoding,
+      normalizeQueryFragmentEncoding,
+      encodeUserinfo,
+      encodeQuery,
+      encodeFragment,
       escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
@@ -3412,7 +3607,7 @@ var require_schemes = __commonJS({
   "node_modules/fast-uri/lib/schemes.js"(exports, module) {
     "use strict";
     var { isUUID } = require_utils();
-    var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+    var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
     var supportedSchemeNames = (
       /** @type {const} */
       [
@@ -3473,9 +3668,10 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path7, query] = wsComponent.resourceName.split("?");
+        const queryIndex = wsComponent.resourceName.indexOf("?");
+        const path7 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
         wsComponent.path = path7 && path7 !== "/" ? path7 : void 0;
-        wsComponent.query = query;
+        wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
         wsComponent.resourceName = void 0;
       }
       wsComponent.fragment = void 0;
@@ -3487,7 +3683,7 @@ var require_schemes = __commonJS({
         return urnComponent;
       }
       const matches = urnComponent.path.match(URN_REG);
-      if (matches) {
+      if (matches && matches[0] === urnComponent.path) {
         const scheme = options.scheme || urnComponent.scheme || "urn";
         urnComponent.nid = matches[1].toLowerCase();
         urnComponent.nss = matches[2];
@@ -3621,8 +3817,17 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
+    var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+    var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+    function decodeValidScheme(scheme) {
+      const decodedScheme = unescape(String(scheme));
+      if (!VALID_SCHEME.test(decodedScheme)) {
+        throw new TypeError(MALFORMED_SCHEME_ERROR);
+      }
+      return decodedScheme;
+    }
     function normalize2(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
@@ -3635,12 +3840,34 @@ var require_fast_uri = __commonJS({
     }
     function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
-      const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
-      if (baseMalformed || relativeMalformed) {
+      const {
+        parsed: baseParsed,
+        malformedAuthorityOrPort: baseMalformed,
+        malformedPercentEncoding: baseMalformedPercentEncoding,
+        malformedSchemeSpecific: baseMalformedSchemeSpecific,
+        malformedHost: baseMalformedHost,
+        malformedScheme: baseMalformedScheme
+      } = parseWithStatus(baseURI, schemelessOptions);
+      const {
+        parsed: relativeParsed,
+        malformedAuthorityOrPort: relativeMalformed,
+        malformedPercentEncoding: relativeMalformedPercentEncoding,
+        malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+        malformedHost: relativeMalformedHost,
+        malformedScheme: relativeMalformedScheme
+      } = parseWithStatus(relativeURI, schemelessOptions);
+      if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
         throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
       }
       const resolved2 = resolveComponent2(baseParsed, relativeParsed, schemelessOptions, true);
+      const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved2.scheme);
+      const resolvedHost = resolved2.host;
+      const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+      canonicalizeHost(resolved2, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+      const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !new RegExp("\\P{ASCII}", "u").test(resolvedHost);
+      if (resolved2.error && !encodedASCIIHost) {
+        throw new Error(resolved2.error);
+      }
       schemelessOptions.skipEscape = true;
       return serialize(resolved2, schemelessOptions);
     }
@@ -3700,7 +3927,7 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       const normalizedA = normalizeComparableURI(uriA, options);
       const normalizedB = normalizeComparableURI(uriB, options);
-      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -3721,19 +3948,22 @@ var require_fast_uri = __commonJS({
       };
       const options = Object.assign({}, opts);
       const uriTokens = [];
+      if (component.scheme) {
+        component.scheme = decodeValidScheme(component.scheme);
+      }
       const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+      const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
+      const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escapePreservingEscapes(component.path);
-          if (component.scheme !== void 0) {
-            component.path = component.path.split("%3A").join(":");
-          }
+          component.path = serializePathEncoding(component.path, pathNoScheme);
         } else {
           component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
+        component.scheme = decodeValidScheme(component.scheme);
         uriTokens.push(component.scheme, ":");
       }
       const authority = recomposeAuthority(component);
@@ -3751,16 +3981,19 @@ var require_fast_uri = __commonJS({
         if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
           s = removeDotSegments(s);
         }
+        if (pathNoScheme) {
+          s = serializePathEncoding(s, true);
+        }
         if (authority === void 0 && s[0] === "/" && s[1] === "/") {
           s = "/%2F" + s.slice(2);
         }
         uriTokens.push(s);
       }
       if (component.query !== void 0) {
-        uriTokens.push("?", component.query);
+        uriTokens.push("?", encodeQuery(component.query));
       }
       if (component.fragment !== void 0) {
-        uriTokens.push("#", component.fragment);
+        uriTokens.push("#", encodeFragment(component.fragment));
       }
       return uriTokens.join("");
     }
@@ -3776,6 +4009,35 @@ var require_fast_uri = __commonJS({
       }
       return void 0;
     }
+    function hasMalformedPercentEncoding(component) {
+      if (component === void 0) return false;
+      let percent = component.indexOf("%");
+      while (percent !== -1) {
+        if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+          return true;
+        }
+        percent = component.indexOf("%", percent + 3);
+      }
+      return false;
+    }
+    function isIPLiteral(host) {
+      return host[0] === "[" && host[host.length - 1] === "]";
+    }
+    function hasMalformedComponentPercentEncoding(matches) {
+      const host = matches[4];
+      return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+    }
+    function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+        try {
+          parsed.host = new URL("http://" + parsed.host).hostname;
+        } catch (e) {
+          parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+          return true;
+        }
+      }
+      return false;
+    }
     function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
@@ -3788,6 +4050,11 @@ var require_fast_uri = __commonJS({
         fragment: void 0
       };
       let malformedAuthorityOrPort = false;
+      let malformedPercentEncoding = false;
+      let malformedSchemeSpecific = false;
+      let malformedHost = false;
+      let malformedIPLiteral = false;
+      let malformedScheme = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -3824,6 +4091,19 @@ var require_fast_uri = __commonJS({
         parsed.path = matches[6] || "";
         parsed.query = matches[7];
         parsed.fragment = matches[8];
+        if (parsed.scheme !== void 0) {
+          const decodedScheme = unescape(parsed.scheme);
+          if (VALID_SCHEME.test(decodedScheme)) {
+            parsed.scheme = decodedScheme.toLowerCase();
+          } else {
+            parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+            malformedScheme = true;
+          }
+        }
+        malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+        if (malformedPercentEncoding) {
+          parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+        }
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
@@ -3835,9 +4115,16 @@ var require_fast_uri = __commonJS({
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
+            const bracketedIPLiteral = isIPLiteral(parsed.host);
+            const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
             const ipv6result = normalizeIPv6(parsed.host);
-            parsed.host = ipv6result.host.toLowerCase();
-            isIP = ipv6result.isIPV6;
+            isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+            malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+            parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+            if (malformedIPLiteral) {
+              parsed.error = parsed.error || "URI host is malformed.";
+              malformedAuthorityOrPort = true;
+            }
           } else {
             isIP = true;
           }
@@ -3855,42 +4142,37 @@ var require_fast_uri = __commonJS({
           parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
         }
         const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-          if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-            try {
-              parsed.host = new URL("http://" + parsed.host).hostname;
-            } catch (e) {
-              parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-            }
+        if (!malformedIPLiteral) {
+          malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
+        }
+        if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+          let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+          if (!isIP) {
+            host = normalizePercentEncoding(host.toLowerCase());
           }
+          parsed.host = reescapeHostDelimiters(host, isIP);
         }
         if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-          if (uri.indexOf("%") !== -1) {
-            if (parsed.scheme !== void 0) {
-              parsed.scheme = unescape(parsed.scheme);
-            }
-            if (parsed.host !== void 0) {
-              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
-            }
-          }
           if (parsed.path) {
             parsed.path = normalizePathEncoding(parsed.path);
           }
+          if (parsed.query) {
+            parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+          }
           if (parsed.fragment) {
-            try {
-              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-            } catch {
-              parsed.error = parsed.error || "URI malformed";
-            }
+            parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
           }
         }
         if (schemeHandler && schemeHandler.parse) {
           schemeHandler.parse(parsed, options);
+          if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) {
+            malformedSchemeSpecific = true;
+          }
         }
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return { parsed, malformedAuthorityOrPort };
+      return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
     }
     function parse4(uri, opts) {
       return parseWithStatus(uri, opts).parsed;
@@ -3899,20 +4181,28 @@ var require_fast_uri = __commonJS({
       return normalizeStringWithStatus(uri, opts).normalized;
     }
     function normalizeStringWithStatus(uri, opts) {
-      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
       return {
-        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-        malformedAuthorityOrPort
+        normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort,
+        malformedPercentEncoding,
+        malformedSchemeSpecific,
+        malformedHost,
+        malformedScheme
       };
     }
     function normalizeComparableURI(uri, opts) {
-      if (typeof uri === "string") {
-        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-        return malformedAuthorityOrPort ? void 0 : normalized;
+      if (typeof uri !== "string" && typeof uri !== "object") {
+        return void 0;
       }
-      if (typeof uri === "object") {
-        return serialize(uri, opts);
+      let value;
+      try {
+        value = typeof uri === "string" ? uri : serialize(uri, opts);
+      } catch {
+        return void 0;
       }
+      const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+      return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
     }
     var fastUri = {
       SCHEMES,
@@ -4332,7 +4622,7 @@ var require_core = __commonJS({
       errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
         if (!errors || errors.length === 0)
           return "No errors";
-        return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
+        return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text2, msg) => text2 + separator + msg);
       }
       $dataMetaSchema(metaSchema, keywordsJsonPointers) {
         const rules = this.RULES.all;
@@ -46823,8 +47113,8 @@ function ko_default() {
 }
 
 // node_modules/zod/v4/locales/lt.js
-var capitalizeFirstCharacter = (text) => {
-  return text.charAt(0).toUpperCase() + text.slice(1);
+var capitalizeFirstCharacter = (text2) => {
+  return text2.charAt(0).toUpperCase() + text2.slice(1);
 };
 function getUnitTypeFromNumber(number4) {
   const abs = Math.abs(number4);
@@ -57051,6 +57341,9 @@ var Protocol = class {
       this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
         const handleTaskResult = async () => {
           const taskId = request.params.taskId;
+          if (!await this._taskStore.getTask(taskId, extra.sessionId)) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+          }
           if (this._taskMessageQueue) {
             let queuedMessage;
             while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
@@ -57081,12 +57374,12 @@ var Protocol = class {
             throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
           }
           if (!isTerminal(task.status)) {
-            await this._waitForTaskUpdate(taskId, extra.signal);
+            await this._waitForTaskUpdate(taskId, extra.signal, extra.sessionId);
             return await handleTaskResult();
           }
           if (isTerminal(task.status)) {
             const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
-            this._clearTaskQueue(taskId);
+            this._clearTaskQueue(taskId, extra.sessionId);
             return {
               ...result,
               _meta: {
@@ -57123,7 +57416,7 @@ var Protocol = class {
             throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
           }
           await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-          this._clearTaskQueue(request.params.taskId);
+          this._clearTaskQueue(request.params.taskId, extra.sessionId);
           const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
           if (!cancelledTask) {
             throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
@@ -57251,6 +57544,19 @@ var Protocol = class {
     const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
     const capturedTransport = this._transport;
     const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+    const sessionId = capturedTransport?.sessionId;
+    const store = this._taskStore;
+    let relatedTaskFound = true;
+    let relatedTaskLookup;
+    if (relatedTaskId && store && this._taskMessageQueue && sessionId !== void 0) {
+      relatedTaskFound = false;
+      relatedTaskLookup = (async () => {
+        if (!await store.getTask(relatedTaskId, sessionId)) {
+          throw new McpError(ErrorCode.InvalidParams, `Task not found: ${relatedTaskId}`);
+        }
+        relatedTaskFound = true;
+      })();
+    }
     if (handler === void 0) {
       const errorResponse = {
         jsonrpc: "2.0",
@@ -57260,7 +57566,10 @@ var Protocol = class {
           message: "Method not found"
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && relatedTaskLookup) {
+        const queuedError = { type: "error", message: errorResponse, timestamp: Date.now() };
+        relatedTaskLookup.then(() => this._enqueueTaskMessage(relatedTaskId, queuedError, sessionId), () => capturedTransport?.send(errorResponse)).catch((error51) => this._onerror(new Error(`Failed to send an error response: ${error51}`)));
+      } else if (relatedTaskId && this._taskMessageQueue) {
         this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -57311,7 +57620,10 @@ var Protocol = class {
       closeSSEStream: extra?.closeSSEStream,
       closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
     };
-    Promise.resolve().then(() => {
+    (relatedTaskLookup ?? Promise.resolve()).then(() => {
+      if (relatedTaskLookup && abortController.signal.aborted) {
+        throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
+      }
       if (taskCreationParams) {
         this.assertTaskHandlerCapability(request.method);
       }
@@ -57346,7 +57658,7 @@ var Protocol = class {
           ...error51["data"] !== void 0 && { data: error51["data"] }
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && this._taskMessageQueue && relatedTaskFound) {
         await this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -57826,7 +58138,7 @@ var Protocol = class {
       throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
     }
     const maxQueueSize = this._options?.maxTaskQueueSize;
-    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+    await this._taskMessageQueue.enqueue(taskId, message, sessionId ?? this._transport?.sessionId, maxQueueSize);
   }
   /**
    * Clears the message queue for a task and rejects any pending request resolvers.
@@ -57855,12 +58167,13 @@ var Protocol = class {
    * Uses polling to check for updates at the task's configured poll interval.
    * @param taskId The task ID to wait for
    * @param signal Abort signal to cancel the wait
+   * @param sessionId Session of the request that waits, passed to the task store
    * @returns Promise that resolves when an update occurs or rejects if aborted
    */
-  async _waitForTaskUpdate(taskId, signal) {
+  async _waitForTaskUpdate(taskId, signal, sessionId) {
     let interval = this._options?.defaultTaskPollInterval ?? 1e3;
     try {
-      const task = await this._taskStore?.getTask(taskId);
+      const task = await this._taskStore?.getTask(taskId, sessionId);
       if (task?.pollInterval) {
         interval = task.pollInterval;
       }
@@ -58739,6 +59052,42 @@ var ExperimentalMcpServerTasks = class {
 };
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
+function toolInputElementCount(value, max) {
+  let count = 0;
+  const stack = [value];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === null || typeof node !== "object")
+      continue;
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        if (++count > max)
+          return count;
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    } else {
+      for (const key in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, key))
+          continue;
+        if (++count > max)
+          return count;
+        const child = node[key];
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    }
+  }
+  return count;
+}
+function resolveMaxToolInputElements(value) {
+  if (value === void 0 || value === Infinity)
+    return void 0;
+  if (typeof value !== "number" || Number.isNaN(value) || value < 1) {
+    throw new RangeError(`maxToolInputElements must be a number of at least 1, or Infinity, got ${String(value)}`);
+  }
+  return value;
+}
 var McpServer = class {
   constructor(serverInfo, options) {
     this._registeredResources = {};
@@ -58750,6 +59099,7 @@ var McpServer = class {
     this._resourceHandlersInitialized = false;
     this._promptHandlersInitialized = false;
     this.server = new Server(serverInfo, options);
+    this._maxToolInputElements = resolveMaxToolInputElements(options?.maxToolInputElements);
   }
   /**
    * Access experimental features.
@@ -58880,12 +59230,15 @@ var McpServer = class {
    * Validates tool input arguments against the tool's input schema.
    */
   async validateToolInput(tool, args, toolName) {
+    if (this._maxToolInputElements !== void 0 && toolInputElementCount(args, this._maxToolInputElements) > this._maxToolInputElements) {
+      throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${toolName}: arguments contain more than the maximum of ${this._maxToolInputElements} elements`);
+    }
     if (!tool.inputSchema) {
       return void 0;
     }
     const inputObj = normalizeObjectSchema(tool.inputSchema);
     const schemaToParse = inputObj ?? tool.inputSchema;
-    const parseResult = await safeParseAsync2(schemaToParse, args);
+    const parseResult = await safeParseAsync2(schemaToParse, args ?? {});
     if (!parseResult.success) {
       const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
       const errorMessage = getParseErrorMessage(error51);
@@ -59123,7 +59476,7 @@ var McpServer = class {
       }
       if (prompt.argsSchema) {
         const argsObj = normalizeObjectSchema(prompt.argsSchema);
-        const parseResult = await safeParseAsync2(argsObj, request.params.arguments);
+        const parseResult = await safeParseAsync2(argsObj, request.params.arguments ?? {});
         if (!parseResult.success) {
           const error51 = "error" in parseResult ? parseResult.error : "Unknown error";
           const errorMessage = getParseErrorMessage(error51);
@@ -59637,6 +59990,79 @@ var StdioServerTransport = class {
   }
 };
 
+// src/mcp/workspaces.ts
+var fail = (text2) => ({ text: text2, isError: true });
+var LEGACY_KEY_NOTE = "This connection uses an older key bound to a single workspace. Call `connect` once (the user approves in the browser) to replace it with one key that reaches every workspace they belong to.";
+var TARGETED_TOOLS = /* @__PURE__ */ new Set(["create_video", "brand_extract", "brand_get", "motion_profile"]);
+var WORKSPACE_ACTING_TOOLS = /* @__PURE__ */ new Set([
+  "create_video",
+  "write_draft_files",
+  "edit_draft_file",
+  "export_video",
+  "brand_extract",
+  "install_kits",
+  "install_font",
+  "install_components",
+  "motion_profile"
+]);
+var CREATING_TOOLS = /* @__PURE__ */ new Set(["create_video", "brand_extract"]);
+var text = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+function admissionTarget(toolName, args, envWorkspace) {
+  const projectId = text(args.projectId);
+  const draftId = text(args.draftId);
+  const jobIds = Array.isArray(args.jobIds) ? args.jobIds.filter((id) => typeof id === "string").slice(0, 50) : void 0;
+  const addressed = Boolean(projectId || draftId || jobIds?.length);
+  const workspace = text(args.workspace) ?? (addressed ? void 0 : envWorkspace);
+  const targeted = TARGETED_TOOLS.has(toolName) || Boolean(text(args.brandSlug));
+  return {
+    ...workspace ? { workspace } : {},
+    ...projectId ? { projectId } : {},
+    ...draftId ? { draftId } : {},
+    ...jobIds?.length ? { jobIds } : {},
+    ...!workspace && !addressed && !targeted ? { all: true } : {}
+  };
+}
+function workspaceNote(toolName, workspace) {
+  const label = workspaceLabel(workspace);
+  const why = workspace.because ? ` (${workspace.because})` : "";
+  return CREATING_TOOLS.has(toolName) ? `Created in ${label}${why}.` : `Workspace: ${label}${why}`;
+}
+function describeRow(workspace, lastOpen) {
+  const usage = workspace.usage;
+  return `- ${workspaceLabel(workspace)}${workspace.id === lastOpen ? " [open in the web app]" : ""} \u2014 role: ${workspace.role || "unknown"}` + (workspace.plan ? `, plan: ${workspace.plan}` : "") + (usage?.summary ? `, ${usage.summary}` : "");
+}
+var listWorkspacesTool = {
+  name: "list_workspaces",
+  title: "List the workspaces this connection can use",
+  description: "List every Impractical workspace the connected user belongs to (id, name, slug, role, plan) and which one is open in the web app. Pass a workspace id, slug or name as `workspace` to create_video / brand_extract to choose where new work goes. Does not use quota.",
+  inputSchema: {},
+  local: true,
+  handler: async (_args, ctx) => {
+    const listing = await fetchWorkspaces(ctx.invoke);
+    if (!listing.supported) {
+      return {
+        text: "This Impractical server does not support workspace listing yet; this connection keeps using its one workspace. account_status shows which."
+      };
+    }
+    if (listing.keyScope !== "user") {
+      const only = listing.workspaces[0];
+      return {
+        text: (only ? `Connected workspace: ${describeRow(only, null).slice(2)}
+
+` : "") + LEGACY_KEY_NOTE
+      };
+    }
+    if (!listing.workspaces.length) {
+      return fail("The connected user is not an active member of any workspace.");
+    }
+    const open = listing.workspaces.find((workspace) => workspace.id === listing.lastOpenWorkspaceId);
+    return {
+      text: "Workspaces:\n" + listing.workspaces.map((workspace) => describeRow(workspace, listing.lastOpenWorkspaceId)).join("\n") + "\n\nLists span all of these. Tools given a project/draft id act in its workspace. New work goes to `workspace` if passed, else " + (open ? `${workspaceLabel(open)}, the one open in the web app.` : listing.workspaces.length === 1 ? "the only workspace." : "the workspace open in the web app \u2014 none is recorded, so pass `workspace` explicitly.")
+    };
+  }
+};
+var WORKSPACE_TOOLS = [listWorkspacesTool];
+
 // src/mcp/contract-mode.ts
 var CONTRACT_ENV = "IMPRACTICAL_CONTRACT";
 function b20Semantics(env = process.env) {
@@ -60511,8 +60937,8 @@ var collectFocusProbe = (input) => {
     if (!parent) break;
     for (const sibling of Array.from(parent.children)) {
       if (sibling === level) continue;
-      const text = textOf(sibling);
-      if (text && siblingTexts.length < 16) siblingTexts.push(text);
+      const text2 = textOf(sibling);
+      if (text2 && siblingTexts.length < 16) siblingTexts.push(text2);
     }
     level = parent;
   }
@@ -60539,11 +60965,11 @@ var NARRATIVE_ENTITY_STOPLIST = new Set(
   "the a an and or but nor to for with without your our their his her its my you we they it this that these those here there now new all one every each more most best better first last next meet introducing get set go from in on at by of no not just say hello welcome today tomorrow how what when where why who which try free start build ship launch power fast easy simple ai app team plan pro data live real time work works make made let us see watch look".split(/\s+/)
 );
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var containsEntity = (text, entity) => new RegExp(`(?:^|[^A-Za-z0-9])${escapeRegExp(entity)}(?:[^A-Za-z0-9]|$)`, "i").test(text);
+var containsEntity = (text2, entity) => new RegExp(`(?:^|[^A-Za-z0-9])${escapeRegExp(entity)}(?:[^A-Za-z0-9]|$)`, "i").test(text2);
 function extractEntityTokens(copy) {
   const out = [];
-  for (const text of copy) {
-    for (const match of text.matchAll(/\b[A-Z][a-zA-Z0-9'&-]*(?:\s+[A-Z][a-zA-Z0-9'&-]*){0,2}\b/g)) {
+  for (const text2 of copy) {
+    for (const match of text2.matchAll(/\b[A-Z][a-zA-Z0-9'&-]*(?:\s+[A-Z][a-zA-Z0-9'&-]*){0,2}\b/g)) {
       const words = match[0].trim().split(/\s+/);
       while (words.length && NARRATIVE_ENTITY_STOPLIST.has(words[0].toLowerCase())) words.shift();
       while (words.length && NARRATIVE_ENTITY_STOPLIST.has(words[words.length - 1].toLowerCase()))
@@ -60565,7 +60991,7 @@ function narrativeCameraFindings(probes) {
       const key = entity.toLowerCase();
       if (flagged.has(key)) continue;
       if (containsEntity(probe.focusedText, entity)) continue;
-      const sibling = probe.siblingTexts.find((text) => containsEntity(text, entity));
+      const sibling = probe.siblingTexts.find((text2) => containsEntity(text2, entity));
       if (!sibling) continue;
       flagged.add(key);
       out.push(
@@ -60803,8 +61229,8 @@ var collectPoseGeometry = (input) => {
     for (const node of Array.from(el2.childNodes)) {
       if (node.nodeType === Node.TEXT_NODE) direct += node.textContent ?? "";
     }
-    const text = direct.trim();
-    if (text.length < 3) continue;
+    const text2 = direct.trim();
+    if (text2.length < 3) continue;
     const r = el2.getBoundingClientRect();
     if (r.width < 2 || r.height < 8) continue;
     const frac = clippedVisibleFraction(r, el2);
@@ -60814,7 +61240,7 @@ var collectPoseGeometry = (input) => {
     edgeTexts.push({
       textId: tagOf(el2, "data-motion-textid"),
       selector: describe3(el2),
-      text: text.slice(0, 60),
+      text: text2.slice(0, 60),
       opacity,
       visibleFraction: frac,
       screenHeight: r.height
@@ -61204,8 +61630,8 @@ var PLATE_EXPOSED_MIN = 0.25;
 var PLATE_PERSISTENCE_MIN = 0.75;
 function parseShotBeats(raw) {
   if (!raw) return [];
-  const text = raw.replace(/^\[shotlist\.json[^\n]*\]\s*\n/, "");
-  const parsed = JSON.parse(text);
+  const text2 = raw.replace(/^\[shotlist\.json[^\n]*\]\s*\n/, "");
+  const parsed = JSON.parse(text2);
   return (parsed.beats ?? []).map((b, i) => ({
     index: i + 1,
     start: Number(b.start ?? 0),
@@ -62333,8 +62759,8 @@ function collectCallerValues(ast) {
       const inner = t3.isJSXExpressionContainer(v) ? v.expression : v;
       if (t3.isJSXEmptyExpression(inner) || t3.isBooleanLiteral(inner) || t3.isNullLiteral(inner)) continue;
       if (t3.isIdentifier(inner) && inner.name === "undefined") continue;
-      const text = t3.isStringLiteral(inner) ? inner.value : t3.isTemplateLiteral(inner) ? inner.quasis.map((q) => q.value.cooked ?? "").join("\u2026") : "";
-      props.set(attr.name.name, [...props.get(attr.name.name) ?? [], text]);
+      const text2 = t3.isStringLiteral(inner) ? inner.value : t3.isTemplateLiteral(inner) ? inner.quasis.map((q) => q.value.cooked ?? "").join("\u2026") : "";
+      props.set(attr.name.name, [...props.get(attr.name.name) ?? [], text2]);
     }
     byComponent.set(el2.name.name, props);
   });
@@ -63008,8 +63434,8 @@ function serializeMarkSet(set2) {
     if (w.overflow) notes.push(`content overflows its box (${w.overflow})`);
     if (!w.visible) notes.push("not visible");
     if (w.src) notes.push(`src ${w.src}`);
-    const text = w.text ? JSON.stringify(w.text) : "\u2014";
-    lines.push(`${w.mark} | ${w.type} | ${text} | ${Math.round(w.rect.x)},${Math.round(w.rect.y)},${Math.round(w.rect.w)},${Math.round(w.rect.h)} | ${w.click ? "yes" : "no"} | ${notes.join("; ") || "\u2014"}`);
+    const text2 = w.text ? JSON.stringify(w.text) : "\u2014";
+    lines.push(`${w.mark} | ${w.type} | ${text2} | ${Math.round(w.rect.x)},${Math.round(w.rect.y)},${Math.round(w.rect.w)},${Math.round(w.rect.h)} | ${w.click ? "yes" : "no"} | ${notes.join("; ") || "\u2014"}`);
   }
   return lines.join("\n");
 }
@@ -64290,7 +64716,7 @@ async function runReviewModules(input) {
             // frame-sized, so geometry cannot tell the target from its wrapper or its children.
             // The author wrote the intent down — world.camera.zoomTo(detailCard, …).
             subjectAt: async (t4) => describeShot(shotAt(shots, t4)),
-            log: (name2, text) => writeFileSync5(path4.join(frameDir, name2), text),
+            log: (name2, text2) => writeFileSync5(path4.join(frameDir, name2), text2),
             // One red box around the element the action names — Set-of-Mark scoped to a single
             // element, so the eye is pointed without the 26-mark noise that hurt the earlier test.
             annotate: async (jpg, action) => {
@@ -64384,7 +64810,7 @@ async function runReviewModules(input) {
             duration: duration3,
             ask: (prompt, images2) => runner(family2)(prompt, images2, { timeoutMs: 3e5 }),
             variant: reviewWalkVariant(),
-            log: (name2, text) => writeFileSync5(path4.join(frameDir, name2), text)
+            log: (name2, text2) => writeFileSync5(path4.join(frameDir, name2), text2)
           });
           for (const f of res.findings) failures.push(`ACTION ${f.index} ${f.start.toFixed(2)}\u2013${f.end.toFixed(2)}s: ${f.label} \u2014 ${f.claim.slice(0, 90)} \u2014 ${f.evidence.slice(0, 160)}`);
         }
@@ -64493,10 +64919,10 @@ async function runReviewModules(input) {
     );
   }
   if (ledger) {
-    const text = describeLedger(ledger);
-    if (text.trim()) {
+    const text2 = describeLedger(ledger);
+    if (text2.trim()) {
       lines.push("  ISSUE LEDGER \u2014 the same defect seen at several actions is ONE issue; support counts how many saw it:");
-      for (const l of text.split("\n")) lines.push("    " + l);
+      for (const l of text2.split("\n")) lines.push("    " + l);
     }
   }
   if (!failures.length) lines.push("  all beats clean \u2014 every module ran and every action was checked; export is not held by the review modules");
@@ -65014,8 +65440,8 @@ function pushAdvisoryEnabled(env = process.env) {
 }
 var lineOf = (content, index) => content.slice(0, index).split("\n").length;
 var scannable = (path7) => !path7.startsWith("kit/") && !path7.endsWith(".json") && !path7.endsWith(".md") && /\.(tsx?|jsx?|css|html)$/.test(path7);
-var clip = (text, max = 90) => {
-  const flat = text.replace(/\s+/g, " ").trim();
+var clip = (text2, max = 90) => {
+  const flat = text2.replace(/\s+/g, " ").trim();
   return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
 };
 var CLASSNAME_RE = /className\s*=\s*(?:"([^"]*)"|'([^']*)'|\{`([^`]*)`\})/g;
@@ -65910,7 +66336,7 @@ async function sampleTextBlocks(page, minFontPx) {
       const viewportHeight = window.innerHeight;
       const margin = 0.02 * Math.min(viewportWidth, viewportHeight);
       const shown = (style) => style.visibility !== "hidden" && style.display !== "none" && !(parseFloat(style.opacity) < 0.05);
-      const describe3 = (el2, text) => {
+      const describe3 = (el2, text2) => {
         const style = getComputedStyle(el2);
         const fontSize = parseFloat(style.fontSize);
         if (!Number.isFinite(fontSize)) return null;
@@ -65929,7 +66355,7 @@ async function sampleTextBlocks(page, minFontPx) {
           }
         }
         return {
-          text: text.slice(0, 40),
+          text: text2.slice(0, 40),
           fontSize,
           x: rect.x,
           y: rect.y,
@@ -65961,8 +66387,8 @@ async function sampleTextBlocks(page, minFontPx) {
       }
       for (const [root, slot] of slotOf) {
         if (!liveRoots.has(root)) continue;
-        const text = (root.textContent ?? "").replace(/\s+/g, " ").trim();
-        out[slot] = describe3(root, text);
+        const text2 = (root.textContent ?? "").replace(/\s+/g, " ").trim();
+        out[slot] = describe3(root, text2);
       }
       return out.filter((block) => block !== null);
     },
@@ -65982,7 +66408,7 @@ var WITNESS_SCALE_FRACTION = 0.04;
 var MIN_WITNESS_SECONDS = 0.9;
 var STATEMENT_HOLD_SECONDS = 1.2;
 var RIDING_DIFF_THRESHOLD = 0.05;
-var normalize = (text) => text.trim().replace(/\s+/g, " ");
+var normalize = (text2) => text2.trim().replace(/\s+/g, " ");
 var settledBetween = (a, b, frameDiagonal) => Math.hypot(a.x + a.width / 2 - (b.x + b.width / 2), a.y + a.height / 2 - (b.y + b.height / 2)) < frameDiagonal * 0.01;
 var ICON_GLYPHS = /^[\s\u2190-\u21FF\u27F0-\u27FF\u2794-\u27BF\u2713\u2714\u2705\u2717\u2718\u2716\u274C\u25B6\u25C0\u25B2\u25BC\u2605\u2606\u2B50]+$|^\s*(->|=>|<-|<=|\[x\]|\[ \])\s*$/;
 function analyzeTextContract(input) {
@@ -66061,12 +66487,12 @@ function analyzeTextContract(input) {
     );
     const firstLocked = lockedLines?.length ? normalize(lockedLines[0]) : null;
     for (const [index, block] of openers.entries()) {
-      const text = normalize(block.text);
-      const isDeclaredOpening = firstLocked ? firstLocked.startsWith(text) || text.startsWith(firstLocked) : index === 0 && openers.length === 1;
+      const text2 = normalize(block.text);
+      const isDeclaredOpening = firstLocked ? firstLocked.startsWith(text2) || text2.startsWith(firstLocked) : index === 0 && openers.length === 1;
       if (!isDeclaredOpening && (firstLocked || openers.length > 1)) {
         findings.push({
           kind: "frame0-leak",
-          detail: `"${text.slice(0, 30)}" is visible at frame 0 but is not the film's opening \u2014 a later element is leaking its initial state. Hide it statically (App.tsx or gsap.set in setup); a from() tween does not hide anything on a cold seek.`
+          detail: `"${text2.slice(0, 30)}" is visible at frame 0 but is not the film's opening \u2014 a later element is leaking its initial state. Hide it statically (App.tsx or gsap.set in setup); a from() tween does not hide anything on a cold seek.`
         });
       }
     }
@@ -66104,13 +66530,13 @@ function analyzeTextContract(input) {
   const glyphSeen = /* @__PURE__ */ new Set();
   for (const sample of samples) {
     for (const block of sample.blocks) {
-      const text = block.text.trim();
-      if (!text || block.fontSize < CANDIDATE_MIN_PX) continue;
-      if (!ICON_GLYPHS.test(text) || glyphSeen.has(text)) continue;
-      glyphSeen.add(text);
+      const text2 = block.text.trim();
+      if (!text2 || block.fontSize < CANDIDATE_MIN_PX) continue;
+      if (!ICON_GLYPHS.test(text2) || glyphSeen.has(text2)) continue;
+      glyphSeen.add(text2);
       findings.push({
         kind: "glyph-icon",
-        detail: `"${text}" is a text glyph doing an icon's job. Use the real icon from lucide-react (import { ArrowRight, Check } from 'lucide-react') \u2014 a glyph inherits the text font, so it sits on the baseline at the wrong weight and optical size, and it cannot take a stroke width or animate as its own element.`
+        detail: `"${text2}" is a text glyph doing an icon's job. Use the real icon from lucide-react (import { ArrowRight, Check } from 'lucide-react') \u2014 a glyph inherits the text font, so it sits on the baseline at the wrong weight and optical size, and it cannot take a stroke width or animate as its own element.`
       });
     }
   }
@@ -70158,11 +70584,11 @@ async function openPreview(ctx, draftId) {
     const consoleTail = [];
     page.on("pageerror", (err) => pageErrors.push((err.stack || err.message || String(err)).slice(0, 900)));
     page.on("console", (msg) => {
-      const text = msg.text();
-      if (/music\.json|connect-src/.test(text)) return;
-      consoleTail.push(`console.${msg.type()}: ${text.slice(0, 300)}`);
+      const text2 = msg.text();
+      if (/music\.json|connect-src/.test(text2)) return;
+      consoleTail.push(`console.${msg.type()}: ${text2.slice(0, 300)}`);
       if (consoleTail.length > 30) consoleTail.shift();
-      if (msg.type() === "error") pageErrors.push("console.error: " + text.slice(0, 600));
+      if (msg.type() === "error") pageErrors.push("console.error: " + text2.slice(0, 600));
     });
     await page.goto(PREVIEW_URL, { waitUntil: "load", timeout: 6e4 });
     try {
@@ -70477,6 +70903,9 @@ var motionContextTool = {
   title: "Study the motion library",
   description: `Retrieve the current versioned house skills, relevant templates, selected production reference sources, the catalog of house kits this draft can install, and rendered style frames for this brief. CALL THIS after engine_types and before create_video. The production library is fetched live; local development may explicitly override its guidance with ${LOCAL_MOTION_LIBRARY_ENV}.`,
   inputSchema: {
+    workspace: external_exports.string().min(1).max(200).optional().describe(
+      "Workspace holding brandSlug (id, slug or name). Default: the one open in the web app, or the only one."
+    ),
     brief: external_exports.string().min(1).describe("What the video should communicate and how it should feel."),
     styleId: external_exports.string().optional().describe("Optional style id from a previous motion_context result."),
     templateId: external_exports.string().optional().describe("Optional template id to study in detail."),
@@ -70721,37 +71150,37 @@ function cameraLint(files) {
     lines.forEach((raw, i) => {
       if (ALLOW.test(raw)) return;
       const line = i + 1;
-      const text = raw.trim().slice(0, 140);
+      const text2 = raw.trim().slice(0, 140);
       if (path7.endsWith("App.tsx") || path7.endsWith(".tsx")) {
         if (APP_STAGE_TRANSFORM.test(raw))
-          out.push({ path: path7, line, text, severity: "note", why: "the stage element carries its own transform \u2014 that is a hand-rolled camera", fix: "remove it; the World Camera moves the stage" });
+          out.push({ path: path7, line, text: text2, severity: "note", why: "the stage element carries its own transform \u2014 that is a hand-rolled camera", fix: "remove it; the World Camera moves the stage" });
         return;
       }
       let m;
       if (RETURN_TIMELINE.test(raw)) {
-        out.push({ path: path7, line, text, severity: "note", why: "the direction returns the timeline \u2014 the stage awaits that value, and a GSAP timeline is a thenable that resolves only when the film COMPLETES; a paused film never does, so the preview never becomes ready", fix: "return nothing from direction (delete this line); the engine already owns ctx.tl" });
+        out.push({ path: path7, line, text: text2, severity: "note", why: "the direction returns the timeline \u2014 the stage awaits that value, and a GSAP timeline is a thenable that resolves only when the film COMPLETES; a paused film never does, so the preview never becomes ready", fix: "return nothing from direction (delete this line); the engine already owns ctx.tl" });
         return;
       }
       if (m = LEGACY.exec(raw)) {
         const verb = m[1];
         const fix = verb === "set" || verb === "full" ? "world.camera.cutTo(subject) (or world.camera.moveTo for a glide)" : verb === "move" ? "film.at(t).do(world.camera.moveTo(subject)) \u2014 name the subject, the verb centres and frames it" : verb === "crop" || verb === "focus" ? "world.camera.zoomTo(subject) (or focusOn)" : "world.camera.moveTo / zoomTo / cutTo / whipTo";
-        out.push({ path: path7, line, text, severity: "note", why: `legacy camera API (camera.${verb})`, fix });
+        out.push({ path: path7, line, text: text2, severity: "note", why: `legacy camera API (camera.${verb})`, fix });
         return;
       }
       if (!b20Semantics() && HAND_TIMED_BOUNDARY.test(raw)) {
-        out.push({ path: path7, line, text, severity: "note", why: "a scene boundary scheduled by hand (film.at(<number>) with an exit/strike/transition)", fix: "film.cut(previous.exit(...), next.enter(...), world.camera.moveTo(...)) \u2014 the sequencer advances on the previous plan's end horizon; typed times are for in-scene cues only" });
+        out.push({ path: path7, line, text: text2, severity: "note", why: "a scene boundary scheduled by hand (film.at(<number>) with an exit/strike/transition)", fix: "film.cut(previous.exit(...), next.enter(...), world.camera.moveTo(...)) \u2014 the sequencer advances on the previous plan's end horizon; typed times are for in-scene cues only" });
         return;
       }
       if (STAGE_TWEEN.test(raw)) {
-        out.push({ path: path7, line, text, severity: "note", why: "a tween on the stage element is a hand-rolled camera move", fix: "world.camera.moveTo / zoomTo on the subject instead" });
+        out.push({ path: path7, line, text: text2, severity: "note", why: "a tween on the stage element is a hand-rolled camera move", fix: "world.camera.moveTo / zoomTo on the subject instead" });
         return;
       }
       if (m = SCENE_ROOT.exec(raw)) {
         const vars = m[1];
         if (SCALE_IN.test(vars))
-          out.push({ path: path7, line, text, severity: "note", why: "scaling a scene root is a zoom in disguise", fix: "world.camera.zoomTo(the component the story is about)" });
+          out.push({ path: path7, line, text: text2, severity: "note", why: "scaling a scene root is a zoom in disguise", fix: "world.camera.zoomTo(the component the story is about)" });
         else if (TRANSLATE_IN.test(vars))
-          out.push({ path: path7, line, text, severity: "note", why: "translating a scene root by hand", fix: "use the engine's exit families or world.strike / world.transition for a scene change" });
+          out.push({ path: path7, line, text: text2, severity: "note", why: "translating a scene root by hand", fix: "use the engine's exit families or world.strike / world.transition for a scene change" });
       }
     });
   }
@@ -70773,6 +71202,8 @@ var UNMETERED_MCP_TOOLS = /* @__PURE__ */ new Set([
   "whoami",
   "upgrade",
   "studio_link",
+  // Lists the user's workspaces (multi-workspace keys); read-only.
+  "list_workspaces",
   // This tool has a packaged local fallback and is explicitly required before
   // authentication-dependent work. Admission must not block that fallback.
   "engine_types"
@@ -70789,8 +71220,9 @@ var createSessionState = () => ({
   shotListByDraft: /* @__PURE__ */ new Map(),
   measuredByDraft: /* @__PURE__ */ new Map()
 });
+var WORKSPACE_ARG = external_exports.string().min(1).max(200).optional();
 var json2 = (value) => ({ text: JSON.stringify(value, null, 2) });
-var fail = (text) => ({ text, isError: true });
+var fail2 = (text2) => ({ text: text2, isError: true });
 var nap = (ctx, ms) => ctx.sleep ? ctx.sleep(ms) : new Promise((resolve) => setTimeout(resolve, ms));
 var TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "canceled"]);
 var POLL_ERROR_LIMIT = 5;
@@ -70888,16 +71320,20 @@ async function measuredBlock(ctx, rows) {
   return parts.length ? "\n\n" + parts.join("\n") : "";
 }
 var getDraft = (ctx, draftId) => ctx.invoke("get-draft", { draftId });
-var studioLink = (ctx, projectId, slug) => {
+var studioLink = (ctx, projectId, slug, workspace = ctx.callWorkspaceId) => {
   const base = (ctx.appUrl ?? "https://motion.impractical.ai").replace(/\/$/, "");
-  return `${base}/projects/${projectId}/studio${slug ? `?scene=${slug}` : ""}`;
+  return `${base}/projects/${projectId}/studio${studioQuery(slug, workspace)}`;
+};
+var resolvedStudioLink = async (ctx, projectId, slug) => {
+  const workspace = ctx.callWorkspaceId ?? await ctx.projectWorkspace?.(projectId).catch(() => null) ?? null;
+  return studioLink(ctx, projectId, slug, workspace);
 };
 async function saveDraft(ctx, draftId, apply) {
   let conflicts = 0;
   while (true) {
     const draft = await getDraft(ctx, draftId);
     if (draft.lockedByJobId) {
-      return fail(
+      return fail2(
         `Draft ${draftId} is locked by job ${draft.lockedByJobId}. Wait for it with job_status({ jobIds: ["${draft.lockedByJobId}"], wait: true }), then retry.`
       );
     }
@@ -70916,7 +71352,7 @@ async function saveDraft(ctx, draftId, apply) {
     const atelierFindings = atelierEnabled() ? await atelierSourceFindings(String(merged["direction.ts"] ?? ""), String(merged["App.tsx"] ?? ""), ctx) : [];
     const preflightError = await preflightDraft(merged);
     if (preflightError) {
-      return fail(
+      return fail2(
         "Local build preflight failed \u2014 nothing was sent to the cloud, fix and save again:\n" + preflightError
       );
     }
@@ -70967,7 +71403,7 @@ async function saveDraft(ctx, draftId, apply) {
         continue;
       }
       if (status === 409) {
-        return fail(
+        return fail2(
           `Save rejected (409): ${message}. The draft changed underneath this edit \u2014 re-read the file and re-apply your change on top of the new content.`
         );
       }
@@ -71037,9 +71473,24 @@ function reviewModulesFailure(capture, session, draftId) {
 var accountStatus = {
   name: "account_status",
   title: "Show account, plan, and MCP usage",
-  description: "Show the connected workspace, current role, plan, weekly MCP usage, reset time, seats, and billing state. Run this once at the start of a session to confirm the connection works.",
+  description: "Show the connected workspace(s) with role, plan, weekly MCP usage, reset time, seats, and billing state. Run this once at the start of a session to confirm the connection works.",
   inputSchema: {},
-  handler: async (_args, ctx) => json2(await ctx.invoke("workspace-bootstrap"))
+  handler: async (_args, ctx) => {
+    const listing = await fetchWorkspaces(ctx.invoke);
+    if (listing.supported && listing.keyScope === "user") {
+      const open = listing.workspaces.find((w) => w.id === listing.lastOpenWorkspaceId);
+      return json2({
+        keyScope: "user",
+        workspaces: listing.workspaces,
+        openInWebApp: open ? workspaceLabel(open) : null,
+        howWorkspacesWork: "This connection reaches every workspace listed. Lists span all of them; tools given a project/draft id act in its workspace; new work goes to `workspace` if passed, else the workspace open in the web app, else the only one."
+      });
+    }
+    const snapshot = await ctx.invoke("workspace-bootstrap");
+    return json2(
+      listing.supported ? { ...snapshot, workspaceAccess: LEGACY_KEY_NOTE } : snapshot
+    );
+  }
 };
 var whoami = {
   ...accountStatus,
@@ -71088,8 +71539,11 @@ var upgradeTool = {
 var listProjects = {
   name: "list_projects",
   title: "List video projects",
-  description: "List video projects in the connected workspace, newest first. Large workspaces: pass limit/offset to page instead of relying on a truncated dump, and nameFilter to search. The tool pages through the server list internally, so totals describe the whole workspace (up to 2,000 projects).",
+  description: "List video projects, newest first \u2014 across every workspace the user belongs to (each project tagged with its workspace), or one workspace with `workspace`. Large lists: pass limit/offset to page instead of relying on a truncated dump, and nameFilter to search. The tool pages through the server list internally, so totals describe the whole listing (up to 2,000 projects in total).",
   inputSchema: {
+    workspace: WORKSPACE_ARG.describe(
+      "Only this workspace (id, slug or name). Default: every workspace you belong to."
+    ),
     limit: external_exports.number().int().min(1).max(200).optional().describe("Return at most this many projects (default: all)."),
     offset: external_exports.number().int().min(0).optional().describe("Skip this many projects, for paging."),
     nameFilter: external_exports.string().optional().describe("Case-insensitive substring match on the project name/slug.")
@@ -71100,7 +71554,9 @@ var listProjects = {
     for (let pageCount = 0; serverOffset !== null && pageCount < 20; pageCount++) {
       const result = await ctx.invoke("list-projects", {
         offset: serverOffset,
-        limit: 100
+        limit: 100,
+        // Spans every workspace for a multi-workspace key; ignored otherwise.
+        ...args.workspace ? {} : { allWorkspaces: true }
       });
       const rows = result.projects ?? [];
       fetched.push(...rows);
@@ -71125,7 +71581,7 @@ var listProjects = {
       offset,
       returned: projects.length,
       hasMore: offset + projects.length < matched,
-      ...truncated ? { note: "Workspace exceeds 2,000 projects; totals reflect the first 2,000." } : {},
+      ...truncated ? { note: "More than 2,000 projects; totals reflect the newest 2,000." } : {},
       projects
     });
   }
@@ -71142,6 +71598,9 @@ var createVideo = {
   title: "Create a video project",
   description: "Create a new video project and an empty draft for you to direct. This does NOT run Impractical's own director \u2014 it scaffolds App.tsx, direction.ts and brand.json and hands them to you. Read the `impractical://engine.d.ts` resource, then write the scene yourself with edit_draft_file / write_draft_files.",
   inputSchema: {
+    workspace: WORKSPACE_ARG.describe(
+      'Workspace to create the video in (id, slug or name \u2014 e.g. when the user says "a video for Rox"). Default: the one open in the web app, else the only one; with several and none open, the call fails listing them. The result says where it landed and why.'
+    ),
     valueProp: external_exports.string().min(1).describe("One or two sentences on what ships and why it matters."),
     name: external_exports.string().optional().describe("Human-readable project name. Defaults to the slug."),
     slug: external_exports.string().optional().describe(
@@ -71167,24 +71626,24 @@ var createVideo = {
   },
   handler: async (args, ctx) => {
     if (ctx.qualityLoop && !args.creativeContract) {
-      return fail(
+      return fail2(
         "The local quality loop requires creativeContract before scaffolding. Name the audience, singleIdea, visualProof, referenceStrategy, productSource, opening, proof, and payoff. This is a planning gate only; it does not change the scene schema."
       );
     }
     if (ctx.phasedFlow) {
       const gate = phasedGateFailure({ concept: args.concept, content: args.content });
-      if (gate) return fail(gate);
+      if (gate) return fail2(gate);
       if (shotListEnabled()) {
         const shotGap = shotListGateFailure(args.concept);
-        if (shotGap) return fail(shotGap);
+        if (shotGap) return fail2(shotGap);
       }
       const refDir = refInjectDir();
       if (refDir) {
         const refGap = refInjectGateFailure(args.concept, refDir);
-        if (refGap) return fail(refGap);
+        if (refGap) return fail2(refGap);
       }
       if (!ctx.qualityLoopState?.referenceLedger) {
-        return fail(
+        return fail2(
           "The phased flow requires gather_references BEFORE create_video: record the real references this film is designed against (or an honest noneFound after exhausting the ladder: local code -> product site -> screenshots -> component-class images)."
         );
       }
@@ -71290,7 +71749,7 @@ var readDraftFile = {
     const path7 = String(args.path);
     const content = draft.files[path7];
     if (content === void 0) {
-      return fail(
+      return fail2(
         `No file "${path7}" in draft ${args.draftId}. Available: ${Object.keys(draft.files).sort().join(", ")}`
       );
     }
@@ -71365,7 +71824,7 @@ var editDraftFile = {
         return { files: { [path7]: next }, deletedPaths: [] };
       }
     );
-    return problem ? fail(problem) : output;
+    return problem ? fail2(problem) : output;
   }
 };
 var jobStatus = {
@@ -71474,7 +71933,7 @@ var exportVideo = {
         gateReform,
         capture: ctx.qualityLoopState?.finalMotionReviewByDraft.get(String(args.draftId))
       }) ?? driftMotionFailure(ctx.qualityLoopState?.finalMotionReviewByDraft.get(String(args.draftId)));
-      if (failure) return fail(`Quality gate blocked export: ${failure}`);
+      if (failure) return fail2(`Quality gate blocked export: ${failure}`);
     }
     const started = await ctx.invoke("start-export", { draftId: args.draftId });
     return json2({
@@ -71490,15 +71949,25 @@ var exportVideo = {
 var brandList = {
   name: "brand_list",
   title: "List brand kits",
-  description: "List the brand kits saved in this workspace.",
-  inputSchema: {},
-  handler: async (_args, ctx) => json2(await ctx.invoke("brand-kits", { action: "list" }))
+  description: "List saved brand kits \u2014 across every workspace the user belongs to (each tagged with its workspace), or one workspace with `workspace`.",
+  inputSchema: {
+    workspace: WORKSPACE_ARG.describe("Only this workspace. Default: all of them.")
+  },
+  handler: async (args, ctx) => json2(await ctx.invoke("brand-kits", {
+    action: "list",
+    ...args.workspace ? {} : { allWorkspaces: true }
+  }))
 };
 var brandGet = {
   name: "brand_get",
   title: "Get a brand kit",
   description: "Get one brand kit \u2014 its colors, fonts and logo. Treat these as law when directing.",
-  inputSchema: { slug: external_exports.string().describe("Brand kit slug.") },
+  inputSchema: {
+    slug: external_exports.string().describe("Brand kit slug."),
+    workspace: WORKSPACE_ARG.describe(
+      "Workspace holding the kit (brand_list shows it). Default: the one open in the web app, or the only one."
+    )
+  },
   handler: async (args, ctx) => json2(await ctx.invoke("brand-kits", { action: "get", slug: args.slug }))
 };
 var brandExtract = {
@@ -71506,6 +71975,9 @@ var brandExtract = {
   title: "Extract a brand kit from a URL",
   description: "Start extracting a brand kit (colors, fonts, logo) from a website and return the run id immediately. To observe an existing run, call this tool with jobId instead of url; that status mode never starts another extraction.",
   inputSchema: {
+    workspace: WORKSPACE_ARG.describe(
+      "Workspace to save the kit in (id, slug or name). Default: the one open in the web app, else the only one; with several and none open, the call fails listing them. Pass the same value when continuing by jobId."
+    ),
     url: external_exports.string().optional().describe("The brand website URL. Omit when continuing by jobId."),
     jobId: external_exports.string().optional().describe("Run id returned by a previous brand_extract call."),
     reextract: external_exports.boolean().optional().describe("Re-extract even if a kit already exists."),
@@ -71517,8 +71989,8 @@ var brandExtract = {
   handler: async (args, ctx, progress) => {
     const url2 = typeof args.url === "string" ? args.url : "";
     const jobId = typeof args.jobId === "string" ? args.jobId : "";
-    if (url2 && jobId) return fail("Pass either url to start or jobId to continue, not both.");
-    if (!url2 && !jobId) return fail("Pass url to start an extraction, or jobId to continue one.");
+    if (url2 && jobId) return fail2("Pass either url to start or jobId to continue, not both.");
+    if (!url2 && !jobId) return fail2("Pass url to start an extraction, or jobId to continue one.");
     if (url2) {
       const started = await ctx.invoke("brand-extraction", {
         action: "start",
@@ -71538,7 +72010,7 @@ var brandExtract = {
     if (!args.wait) {
       const status = await readStatus();
       if (status.status === "error" || status.status === "failed" || status.error) {
-        return fail(`Brand extraction failed${status.error ? `: ${status.error}` : ""}`);
+        return fail2(`Brand extraction failed${status.error ? `: ${status.error}` : ""}`);
       }
       return json2({ jobId, ...status });
     }
@@ -71560,7 +72032,7 @@ var brandExtract = {
           return json2({ jobId, ...status });
         }
         if (status.status === "error" || status.status === "failed" || status.error) {
-          return fail(`Brand extraction failed${status.error ? `: ${status.error}` : ""}`);
+          return fail2(`Brand extraction failed${status.error ? `: ${status.error}` : ""}`);
         }
       } catch (error51) {
         lastError = error51 instanceof Error ? error51.message : String(error51);
@@ -71588,6 +72060,9 @@ var motionProfile = {
   title: "Manage the personal motion profile",
   description: "Inspect and manage the user's learned motion preferences. Call with action 'get' to see the effective profile before directing. Use 'remember' ONLY when the user explicitly asks to remember a preference; use 'propose' to submit an inferred preference as a pending proposal for the user to confirm \u2014 never confirm an inferred preference yourself. 'confirm'/'reject' decide a pending proposal after asking the user; 'forget', 'pause', 'resume' and 'reset' manage stored preferences on the user's behalf.",
   inputSchema: {
+    workspace: WORKSPACE_ARG.describe(
+      "Workspace whose profile layers to use. Default: the draft's workspace when draftId is given, else the one open in the web app, else the only one."
+    ),
     action: external_exports.enum(["get", "remember", "propose", "confirm", "reject", "forget", "pause", "resume", "reset"]).describe("The profile command to run."),
     rule: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe(
       "Structured preference for remember/propose, e.g. {kind:'trait',trait:'pacing',value:'fast'}, {kind:'library',itemType:'style',itemId:'optical',stance:'prefer'}, {kind:'freeform',text:'...'}, {kind:'duration',max:15}, or {kind:'example',draftId:'...'}."
@@ -71599,7 +72074,10 @@ var motionProfile = {
     contentType: external_exports.string().optional().describe("Content type this preference applies to."),
     draftId: external_exports.string().optional().describe("Draft that motivated a proposal.")
   },
-  handler: async (args, ctx) => json2(await ctx.invoke("motion-profile", args))
+  handler: async (args, ctx) => {
+    const { workspace: _workspace, ...body } = args;
+    return json2(await ctx.invoke("motion-profile", body));
+  }
 };
 var studioLinkTool = {
   name: "studio_link",
@@ -71610,7 +72088,7 @@ var studioLinkTool = {
     slug: external_exports.string().optional().describe("Draft slug to open directly.")
   },
   handler: async (args, ctx) => ({
-    text: studioLink(ctx, String(args.projectId), args.slug)
+    text: await resolvedStudioLink(ctx, String(args.projectId), args.slug)
   })
 };
 var REMOTE_SAFE_TOOLS = [
@@ -71759,10 +72237,10 @@ function kitCatalog(sources, {
         if (header.length) break;
         continue;
       }
-      const text = line.replace(/^\/\/\s*/, "").replace(/[─]+/g, "").trim();
-      if (!text) continue;
-      if (!header.length) standsAlone = KIT_TITLE_BAR.test(raw) || /[.!?]$/.test(text);
-      header.push(text);
+      const text2 = line.replace(/^\/\/\s*/, "").replace(/[─]+/g, "").trim();
+      if (!text2) continue;
+      if (!header.length) standsAlone = KIT_TITLE_BAR.test(raw) || /[.!?]$/.test(text2);
+      header.push(text2);
       if (header.length >= (headerMode === "title" && standsAlone ? 1 : 2)) break;
     }
     const exports = [...file2.content.matchAll(/^export (?:const|function) (\w+)/gm)].map((m) => m[1]).filter((n) => !n.startsWith("_")).filter(
@@ -72298,7 +72776,7 @@ var openStudioTool = {
     slug: external_exports.string().optional().describe("Draft slug to open directly.")
   },
   handler: async (args, ctx) => {
-    const url2 = studioLink(ctx, String(args.projectId), args.slug);
+    const url2 = await resolvedStudioLink(ctx, String(args.projectId), args.slug);
     const needle = `/projects/${String(args.projectId)}`;
     try {
       const existing = await findOpenStudioTab(needle);
@@ -72320,9 +72798,11 @@ var openStudioTool = {
 // src/mcp/connect.ts
 var CONNECT_WAIT_SECONDS = 300;
 async function connectWorkspace(input, deps) {
-  const grant = await deps.request(deps.supabaseUrl, "cli-device-auth", {
-    action: "start"
-  });
+  const grant = await deps.request(
+    deps.supabaseUrl,
+    "cli-device-auth",
+    DEVICE_START_BODY
+  );
   const browserOpened = deps.open(grant.verificationUri);
   const expiry = Date.parse(grant.expiresAt);
   const deadline = Math.min(
@@ -72347,7 +72827,12 @@ async function connectWorkspace(input, deps) {
         supabaseUrl: deps.supabaseUrl,
         appUrl: deps.appUrl
       });
-      return { status: "connected", userCode: grant.userCode, browserOpened };
+      return {
+        status: "connected",
+        userCode: grant.userCode,
+        browserOpened,
+        keyScope: grantScope(poll)
+      };
     }
     await deps.sleep(intervalMs);
   }
@@ -72361,7 +72846,7 @@ async function connectWorkspace(input, deps) {
 var connectTool = {
   name: "connect",
   title: "Connect this workspace",
-  description: "Authenticate Impractical Motion for this machine. Opens the user's browser to approve the connection, waits for them to confirm, and stores the credential locally. TELL THE USER YOU ARE ABOUT TO OPEN THEIR BROWSER BEFORE CALLING THIS \u2014 the call blocks until they approve. Use it whenever a tool reports that the workspace is not connected.",
+  description: "Authenticate Impractical Motion for this machine. Opens the user's browser to approve the connection, waits for them to confirm, and stores the credential locally. TELL THE USER YOU ARE ABOUT TO OPEN THEIR BROWSER BEFORE CALLING THIS \u2014 the call blocks until they approve. Use it whenever a tool reports that the workspace is not connected. The key it stores reaches every workspace the user belongs to; calling it again also upgrades an older single-workspace connection.",
   inputSchema: {
     waitSeconds: external_exports.number().optional().describe(`How long to wait for browser approval. Default ${CONNECT_WAIT_SECONDS}.`)
   },
@@ -72392,6 +72877,13 @@ var connectTool = {
       };
     }
     try {
+      if (result.keyScope === "user") {
+        const listing = await fetchWorkspaces(ctx.invoke);
+        const open = listing.workspaces.find((w) => w.id === listing.lastOpenWorkspaceId);
+        return {
+          text: `Connected. This key reaches all ${listing.workspaces.length} of the user's workspaces: ` + listing.workspaces.map(workspaceLabel).join(", ") + ". Lists span all of them; tools that address a project or draft act in its workspace; new videos go to the workspace named with `workspace`, else " + (open ? `the one open in the web app (now ${workspaceLabel(open)})` : "the one open in the web app") + (listing.workspaces.length === 1 ? " \u2014 here the only one." : ".")
+        };
+      }
       const snapshot = await ctx.invoke(
         "workspace-bootstrap"
       );
@@ -72448,6 +72940,7 @@ var engineTypesTool = {
 };
 var TOOLS = [
   connectTool,
+  ...WORKSPACE_TOOLS,
   upgradeTool,
   ...REMOTE_SAFE_TOOLS,
   getFramesTool,
@@ -72565,12 +73058,23 @@ function register(server, tool, ctx) {
     async (args, extra) => {
       try {
         const admissionName = tool.admitAs ?? tool.name;
-        const admission = ctx.admit && !UNMETERED_MCP_TOOLS.has(admissionName) ? await ctx.admit(admissionName) : null;
-        const execute = () => tool.handler(args ?? {}, ctx, toolProgress(extra));
-        const output = admission?.receipt && ctx.withAdmission ? await ctx.withAdmission(admission.receipt, execute) : await execute();
+        const admission = ctx.admit && !UNMETERED_MCP_TOOLS.has(admissionName) ? await ctx.admit(
+          admissionName,
+          admissionTarget(tool.name, args ?? {}, ctx.defaultWorkspace)
+        ) : null;
+        const admitted = admission?.keyScope === "user" ? admission.workspace ?? null : null;
+        const linkWorkspace = admission?.workspace?.id && admission.workspace.reason !== "any" ? admission.workspace.id : void 0;
+        const callCtx = linkWorkspace ? { ...ctx, callWorkspaceId: linkWorkspace } : ctx;
+        const execute = () => tool.handler(args ?? {}, callCtx, toolProgress(extra));
+        const output = admission?.receipt && ctx.withAdmission ? await ctx.withAdmission(admission.receipt, execute, admitted?.id) : await execute();
         if (admission?.warning) output.text += `
 
 ${formatUsageNotice(admission.warning)}`;
+        if (admitted && !output.isError && WORKSPACE_ACTING_TOOLS.has(tool.name)) {
+          output.text += `
+
+${workspaceNote(tool.name, admitted)}`;
+        }
         return toContent(output);
       } catch (error51) {
         const status = error51.status;
@@ -72588,7 +73092,11 @@ ${formatUsageNotice(admission.warning)}`;
             isError: true
           });
         }
-        const hint = status === 401 || isNotConnected(message) ? "\n\nCall the `connect` tool to authenticate this workspace." : status === 402 ? "\n\nThe workspace needs an active subscription or trial." : "";
+        const hint = status === 401 || isNotConnected(message) ? "\n\nCall the `connect` tool to authenticate this workspace." : status === 409 && details?.error === "workspace_selection_required" ? `
+
+The user belongs to several workspaces${workspaceChoices(details)} and none was named or open in the web app. Ask which one, then retry with \`workspace\`.` : status === 403 && details?.error === "workspace_access_denied" ? `
+
+That workspace is not available to this user${workspaceChoices(details)}. Call list_workspaces and retry with one of them.` : status === 402 ? "\n\nThe workspace needs an active subscription or trial." : "";
         return toContent({ text: `${tool.name} failed: ${message}${hint}`, isError: true });
       }
     }
@@ -72678,6 +73186,31 @@ function createServer(ctx) {
   registerEngineResource(server);
   return server;
 }
+function workspaceChoices(details) {
+  const list = Array.isArray(details?.workspaces) ? details.workspaces : [];
+  const names = list.filter((row) => typeof row === "object" && row !== null && typeof row.id === "string" && /^[A-Za-z0-9_-]{1,100}$/.test(row.id)).slice(0, 20).map(
+    (row) => typeof row.name === "string" && row.name.length <= 100 ? `${row.name.replace(/[\u0000-\u001f]/g, "")} \u2014 ${row.id}` : row.id
+  );
+  return names.length ? ` (${names.join(", ")})` : "";
+}
+function createProjectWorkspaceLookup(request = (body) => {
+  const { apiKey, supabaseUrl } = requireConfig();
+  return invokeAt(supabaseUrl, "workspace-bootstrap", body, apiKey);
+}) {
+  const cache2 = /* @__PURE__ */ new Map();
+  return async (projectId) => {
+    if (cache2.has(projectId)) return cache2.get(projectId) ?? null;
+    let id = null;
+    try {
+      const result = await request({ action: "project_workspace", projectId });
+      id = typeof result?.workspace?.id === "string" ? result.workspace.id : null;
+    } catch {
+      id = null;
+    }
+    cache2.set(projectId, id);
+    return id;
+  };
+}
 async function runStdioServer() {
   const config2 = loadConfig();
   if (!config2.apiKey) {
@@ -72699,7 +73232,9 @@ async function runStdioServer() {
     phasedFlow: phasedFlowEnabled(),
     // stdio runs on the user's machine, so completed preview builds can be
     // measured in the local browser and answered with what the frame became.
-    measurePreview: measureStage
+    measurePreview: measureStage,
+    defaultWorkspace: config2.workspace,
+    projectWorkspace: createProjectWorkspaceLookup()
   });
   await server.connect(new StdioServerTransport());
   const served = TOOLS.length + 2 + createComponentTools().length + (motionLabEnabled() ? 1 : 0) + (phasedFlowEnabled() ? 1 : 0);
@@ -72709,6 +73244,7 @@ async function runStdioServer() {
 export {
   ENGINE_DTS_URI,
   buildServerInstructions,
+  createProjectWorkspaceLookup,
   createServer,
   runStdioServer
 };