I know not everyone uses metascripts  (or more info here ), but they can provide certain functionalities Roll20 lacks, or extend others that Roll20 has. Recently I found 2 ways of preserving roll queries in included atributes/abilities/macros, so I wanted to share them. These might be too deep in the meta for some. Or they might seem approachable in the simplified examples, but could prove difficult to adapt to your situation. If you have any questions, just post with what you're looking for. For now, here are the two cases where metascripts can help. Case 1 - Self-Healing Command Line The Problem:  If you retrieve an item (attribute/ability/macro) during the course of a script and wish to dispatch it as its own message (for instance, issuing a command from ScriptCards, or deriving the command you want to execute via RecursiveTables, or arriving at the command line via metascript chicanery), and if that retrieved item has a roll query in it, you will not be prompted with the roll query. You won't have the chance to provide the answer to the roll query, because by the time the item is retrieved, you've already passed the stage in the message processing where Roll20 would detect the query and raise it in the interface. The Fix: In this case, you can have the retrieved item detect whether it has been called directly (so the query prompt would display), or whether it had been called via another script (so the query was never sent). Example: Here is a simple example of this, in an ability named SelfHealing on a character named Kokoro . The command at the core of this is a TokenMod call to set bar1 equal to the results of a query. !{\&if "queryVar" = "?\{Value}"}[Roll](~Kokoro|SelfHealing) {&simple}{&else}!token-mod --set bar1|?{Value}{\&end}{&global ([queryVar] ?{Value})} In this case, ZeroFrame catches the query result as a global variable named queryVar . On a delay, APILogic tests if the variable is still equal to the original query language (the delay is important because that's how we break up the query syntax so Roll20 doesn't automatically replace it in the case of a user-initiated call). In the case of a user-initiated call, the query will be filled, and it will no longer *be* the query syntax. That prompts the TokenMod call to happen. On a script-initiated call, there wouldn't be a chance for the query to fill, so the conditional will instead output a button that is set up to call the very same ability (calling itself). Because it is a button, when the player clicks it, you have a user-initiated message, and the TokenMod call happens. REQUIRED SCRIPTS - ZeroFrame, APILogic, (and, for this example, TokenMod) Case 2 - Nested Roll Queries The Problem:  Using Roll20 syntax, if you want to retrieve an item (attribute/ability/macro) in a query, and that retrieved item contains characters that could break the query (a vertical pipe, a right brace, or a comma), you have to do HTML replacements on those characters so that they don't break the query. However, if you do that, then you can't run the retrieved item on its own -- it can only be run from being nested in a query. Replacing the Roll20 standard syntax with Fetch syntax can bypass this problem since Fetch is only retrieved after the roll query has processed (so the fetched characters can no longer break the query). This much has been known, along with the problem with this approach that if the retrieved item also includes a query, you won't get the query prompt (because it gets retrieved after the roll query processing). The Fix: If the retrieved item were a completely self-contained command line, you could use the Self-Healing form, above... or you could use this method. However, if it is just a building block to your command line, you can't dispatch it on its own and you'll have to use this method. To do this workaround, include the query in the parent macro and assign it to a global variable. When you retrieve the item (using Fetch syntax so that it doesn't break the query in the parent macro), the query will still be in the retrieved text, unresolved. The global variable will replace it with the result of the query (derived at the top level of the message). Example: Here is an example using fully self-contained command lines (since this form will make the query in the parent macro simpler to read). This example uses 3 abilities: SubQuery1, SubQuery2 (both on the Kokoro character), and ParentQuery. SubQuery1 !This is subquery1 ?{Input|0}{&simple} SubQuery2 !This is subquery2 ?{Input|0}{&simple} ParentQuery !?{Choose ability|SubQuery1,%(Kokoro.SubQuery1)|SubQuery2,%(Kokoro.SubQuery2)}{\&global ([?\{Input|0}] ?{Input|0})} Again, we delay the variable name by using the backslash, which means we need to delay capturing the variable (using {&global...}) in the same way. However, once captured, the fetched contents are returned to our command line, and ZeroFrame searches for the stored variable name (the query syntax). When found, it replaces the query syntax with what you originally supplied. REQUIRED SCRIPTS - ZeroFrame, Fetch