diff --git a/build.gradle b/build.gradle
index b7c8c60..ce9bd56 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,7 +1,7 @@
 import org.apache.tools.ant.filters.ReplaceTokens
 
 buildscript {
-    ext.kotlin_version = '1.1.51'
+    ext.kotlin_version = '1.2.0'
 
     repositories {
         mavenCentral()
@@ -22,7 +22,7 @@ plugins {
 apply plugin: 'kotlin'
 
 group = 'gg.obsidian'
-version = '3.0.1'
+version = '3.1.0'
 description = """Bridge chat between Minecraft and Discord"""
 ext.url = 'https://github.com/the-obsidian/DiscordBridge'
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt b/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt
index adf5411..b84c691 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/Plugin.kt
@@ -136,7 +136,7 @@ class Plugin : JavaPlugin() {
     /**
      * Saves all default configs where configs do not exist and reloads data from file into memory
      */
-    fun updateConfig(version: String) {
+    private fun updateConfig(version: String) {
         this.saveDefaultConfig()
         config.options().copyDefaults(true)
         config.set("version", version)
@@ -182,7 +182,7 @@ class Plugin : JavaPlugin() {
         val users = Connection.listUsers()
         val found: Member = users.find { it.user.name + "#" + it.user.discriminator == discriminator } ?: return null
 
-        val ua: UserAlias = UserAlias(player.uniqueId, found.user.id)
+        val ua = UserAlias(player.uniqueId, found.user.id)
         requests.add(ua)
         val msg = "Minecraft user '${server.getOfflinePlayer(ua.mcUuid).name}' has requested to become associated with your Discord" +
                 " account. If this is you, respond '${Connection.JDA.selfUser.asMention} confirm'. If this is not" +
@@ -203,8 +203,8 @@ class Plugin : JavaPlugin() {
 
         var response = "${CC.YELLOW}Discord users:"
         for (user in users) {
-            if (user.user.isBot) response += "\n${CC.GOLD}- ${user.effectiveName} (Bot) | ${user.user.name}#${user.user.discriminator}${CC.RESET}"
-            else response += "\n${CC.YELLOW}- ${user.effectiveName} | ${user.user.name}#${user.user.discriminator}${CC.RESET}"
+            response += if (user.user.isBot) "\n${CC.GOLD}- ${user.effectiveName} (Bot) | ${user.user.name}#${user.user.discriminator}${CC.RESET}"
+            else "\n${CC.YELLOW}- ${user.effectiveName} | ${user.user.name}#${user.user.discriminator}${CC.RESET}"
         }
         return response.trim()
     }
@@ -218,25 +218,25 @@ class Plugin : JavaPlugin() {
             return "${CC.YELLOW}No Discord members could be found. Either server is empty or an error has occurred."
 
         var response = ""
-        if (onlineUsers.filter { it.onlineStatus == OnlineStatus.ONLINE }.isNotEmpty()) {
+        if (onlineUsers.any { it.onlineStatus == OnlineStatus.ONLINE }) {
             response += "\n${CC.DARK_GREEN}Online:${CC.RESET}"
             for (user in onlineUsers.filter { it.onlineStatus == OnlineStatus.ONLINE }) {
-                if (user.user.isBot) response += "\n${CC.DARK_GREEN}- ${user.effectiveName} (Bot)${CC.RESET}"
-                else response += "\n${CC.DARK_GREEN}- ${user.effectiveName}${CC.RESET}"
+                response += if (user.user.isBot) "\n${CC.DARK_GREEN}- ${user.effectiveName} (Bot)${CC.RESET}"
+                else "\n${CC.DARK_GREEN}- ${user.effectiveName}${CC.RESET}"
             }
         }
-        if (onlineUsers.filter { it.onlineStatus == OnlineStatus.IDLE }.isNotEmpty()) {
+        if (onlineUsers.any { it.onlineStatus == OnlineStatus.IDLE }) {
             response += "\n${CC.YELLOW}Idle:${CC.RESET}"
             for (user in onlineUsers.filter { it.onlineStatus == OnlineStatus.IDLE }) {
-                if (user.user.isBot) response += "\n${CC.YELLOW}- ${user.effectiveName} (Bot)${CC.RESET}"
-                else response += "\n${CC.YELLOW}- ${user.effectiveName}${CC.RESET}"
+                response += if (user.user.isBot) "\n${CC.YELLOW}- ${user.effectiveName} (Bot)${CC.RESET}"
+                else "\n${CC.YELLOW}- ${user.effectiveName}${CC.RESET}"
             }
         }
-        if (onlineUsers.filter { it.onlineStatus == OnlineStatus.DO_NOT_DISTURB }.isNotEmpty()) {
+        if (onlineUsers.any { it.onlineStatus == OnlineStatus.DO_NOT_DISTURB }) {
             response += "\n${CC.RED}Do Not Disturb:${CC.RESET}"
             for (user in onlineUsers.filter { it.onlineStatus == OnlineStatus.DO_NOT_DISTURB }) {
-                if (user.user.isBot) response += "\n${CC.RED}- ${user.effectiveName} (Bot)${CC.RESET}"
-                else response += "\n${CC.RED}- ${user.effectiveName}${CC.RESET}"
+                response += if (user.user.isBot) "\n${CC.RED}- ${user.effectiveName} (Bot)${CC.RESET}"
+                else "\n${CC.RED}- ${user.effectiveName}${CC.RESET}"
             }
         }
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt b/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt
index 2398afa..05e8b41 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/UserAliasConfig.kt
@@ -13,7 +13,7 @@ object UserAliasConfig {
      */
     fun load(plugin: Plugin) {
         val list = plugin.users.data.getList("aliases")
-        if (list != null) aliases = list.checkItemsAre<UserAlias>() ?:
+        if (list != null) aliases = list.checkItemsAre() ?:
                 throw IllegalStateException("usernames.yml could not be read - list items are not properly formatted")
         else mutableListOf<UserAlias>()
     }
@@ -42,5 +42,5 @@ object UserAliasConfig {
      * A function to assert that all the items in a given list are of a specific type
      */
     @Suppress("UNCHECKED_CAST")
-    inline fun <reified T : Any> List<*>.checkItemsAre() = if (all { it is T }) this as List<T> else null
+    private inline fun <reified T : Any> List<*>.checkItemsAre() = if (all { it is T }) this as List<T> else null
 }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/DiscordCommandSender.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/DiscordCommandSender.kt
new file mode 100644
index 0000000..8658bcf
--- /dev/null
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/DiscordCommandSender.kt
@@ -0,0 +1,96 @@
+package gg.obsidian.discordbridge.commands
+
+import net.dv8tion.jda.core.entities.MessageChannel
+import org.bukkit.Bukkit
+import org.bukkit.Server
+import org.bukkit.command.CommandSender
+import org.bukkit.command.ConsoleCommandSender
+import org.bukkit.command.RemoteConsoleCommandSender
+import org.bukkit.permissions.Permission
+import org.bukkit.permissions.PermissionAttachment
+import org.bukkit.permissions.PermissionAttachmentInfo
+import org.bukkit.plugin.Plugin
+
+class DiscordCommandSender(val channel: MessageChannel) : RemoteConsoleCommandSender {
+
+    private val sender:ConsoleCommandSender = Bukkit.getServer().consoleSender
+
+    init {
+
+    }
+
+    override fun sendMessage(message: String?) {
+        channel.sendMessage(message).queue()
+    }
+
+    override fun sendMessage(messages: Array<out String>?) {
+        if (messages != null)
+            for (m in messages) channel.sendMessage(m)
+    }
+
+    override fun spigot(): CommandSender.Spigot {
+        return sender.spigot()
+    }
+
+    override fun addAttachment(plugin: Plugin?): PermissionAttachment {
+        return sender.addAttachment(plugin)
+    }
+
+    override fun addAttachment(plugin: Plugin?, ticks: Int): PermissionAttachment {
+        return sender.addAttachment(plugin, ticks)
+    }
+
+    override fun addAttachment(plugin: Plugin?, name: String?, value: Boolean): PermissionAttachment {
+        return sender.addAttachment(plugin, name, value)
+    }
+
+    override fun addAttachment(plugin: Plugin?, name: String?, value: Boolean, ticks: Int): PermissionAttachment {
+        return sender.addAttachment(plugin, name, value, ticks)
+    }
+
+    override fun getEffectivePermissions(): MutableSet<PermissionAttachmentInfo> {
+        return sender.effectivePermissions
+    }
+
+    override fun getName(): String {
+        return sender.name
+    }
+
+    override fun getServer(): Server {
+        return sender.server
+    }
+
+    override fun hasPermission(name: String?): Boolean {
+        return sender.hasPermission(name)
+    }
+
+    override fun hasPermission(perm: Permission?): Boolean {
+        return sender.hasPermission(perm)
+    }
+
+    override fun isOp(): Boolean {
+        return sender.isOp
+    }
+
+    override fun isPermissionSet(name: String?): Boolean {
+        return sender.isPermissionSet(name)
+    }
+
+    override fun isPermissionSet(perm: Permission?): Boolean {
+        return sender.isPermissionSet(perm)
+    }
+
+    override fun recalculatePermissions() {
+        return sender.recalculatePermissions()
+    }
+
+    override fun removeAttachment(attachment: PermissionAttachment?) {
+        return sender.removeAttachment(attachment)
+    }
+
+    override fun setOp(value: Boolean) {
+        return sender.setOp(value)
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/annotations/BotCommand.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/annotations/BotCommand.kt
index ed1de34..766751f 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/annotations/BotCommand.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/annotations/BotCommand.kt
@@ -7,9 +7,9 @@ package gg.obsidian.discordbridge.commands.annotations
  * @param description a short string that describes the command's function
  * @param name an optional field to override the command's access name if it is not the same as the method name
  * @param relayTriggerMessage whether the message used to trigger this command should be relayed
- * @param ignoreExcessArguments if false, this command will fail if the invoker provides too many arguments
+ * @param squishExcessArgs if true, this command will put all extra args passed to it into a single string
  */
 @Target(AnnotationTarget.FUNCTION)
 @Retention(AnnotationRetention.RUNTIME)
 annotation class BotCommand(val usage: String, val description: String, val name: String = "",
-                            val relayTriggerMessage: Boolean = true, val ignoreExcessArguments: Boolean = true)
+                            val relayTriggerMessage: Boolean = true, val squishExcessArgs: Boolean = false)
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
index 2a40453..8f09c83 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/BotControllerManager.kt
@@ -11,6 +11,8 @@ import gg.obsidian.discordbridge.utils.UtilFunctions.noSpace
 import gg.obsidian.discordbridge.utils.UtilFunctions.stripColor
 import gg.obsidian.discordbridge.utils.UtilFunctions.toDiscordChatMessage
 import gg.obsidian.discordbridge.utils.UtilFunctions.toMinecraftChatMessage
+import net.dv8tion.jda.core.Permission
+import org.bukkit.Bukkit
 import java.lang.reflect.Method
 import java.util.*
 import java.util.logging.Level
@@ -29,6 +31,9 @@ class BotControllerManager(val plugin: Plugin) {
     private val commands: MutableMap<String, Command> = mutableMapOf()
     private val controllers: MutableMap<Class<out IBotController>, IBotController> = mutableMapOf()
 
+    // =============================================
+    // =============== SETUP METHODS ===============
+
     /**
      * Adds an IBotController to the manager.
      *
@@ -71,14 +76,17 @@ class BotControllerManager(val plugin: Plugin) {
         if (methodParameters.isEmpty() || !methodParameters[0].type.isAssignableFrom(IEventWrapper::class.java)) return
 
         method.isAccessible = true
-        val parameters = (1..methodParameters.size - 1).mapTo(ArrayList<Class<*>>()) { methodParameters[it].type }
+        val parameters = (1 until methodParameters.size).mapTo(ArrayList<Class<*>>()) { methodParameters[it].type }
         val isTagged: Boolean = method.getAnnotation(TaggedResponse::class.java) != null
         val isPrivate: Boolean = method.getAnnotation(PrivateResponse::class.java) != null
         val command = Command(commandName, usage, annotation.description, parameters, annotation.relayTriggerMessage,
-                annotation.ignoreExcessArguments, isTagged, isPrivate, controllerClass, method)
+                annotation.squishExcessArgs, isTagged, isPrivate, controllerClass, method)
         commands.put(command.name, command)
     }
 
+    // =============================================
+    // ============== MESSAGE HANDLING =============
+
     /**
      * Reads an incoming message and attempts to parse and execute a command.
      *
@@ -94,58 +102,31 @@ class BotControllerManager(val plugin: Plugin) {
                 commandNotFound(event, event.command.name)
                 return true
             }
-            val inputArguments = event.rawMessage.split("\\s+".toRegex(), command.parameters.size).toTypedArray()
-            return invokeCommand(command, controllers, event, inputArguments)
+            return invokeBotCommand(command, controllers, event, event.args.asList().toTypedArray())
         }
 
         // Short circuit scripted responses
-        if (scriptedResponse(event)) return true
-
-        val args = event.rawMessage.trim().split("\\s+".toRegex(), 2).toTypedArray()
+        if (sendScriptedResponse(event)) return true
 
         // <prefix>command
-        if (Config.COMMAND_PREFIX.isNotBlank() && args[0].startsWith(Config.COMMAND_PREFIX)) {
-            val commandName = args[0].substring(Config.COMMAND_PREFIX.length).toLowerCase()
-            if (commandName == "") return true
-            val command = commands[commandName]
-
-            if (command == null) {
-                commandNotFound(event, commandName)
-                return false
-            }
-
-            val inputArguments = if (args.size == 1) arrayOf<String>()
-            else args[1].split("\\s+".toRegex(), command.parameters.size).toTypedArray()
-
-            return invokeCommand(command, controllers, event, inputArguments)
+        if (Config.COMMAND_PREFIX.isNotBlank() && event.rawMessage.startsWith(Config.COMMAND_PREFIX)) {
+            val split = event.rawMessage.replaceFirst(Config.COMMAND_PREFIX, "").trim().split("\\s+".toRegex()).toTypedArray()
+            return parseCommand(event, split, false)
         }
 
-        // @<mention> command
-        if ((event is AsyncPlayerChatEventWrapper && args[0] == "@"+Config.USERNAME.noSpace() ||
-                args[0] == Connection.JDA.selfUser.asMention) && args.count() == 2) {
-            val args2 = args[1].split("\\s+".toRegex(), 2).toTypedArray()
-            val commandName = args2[0].toLowerCase()
-            if (commandName == "") return true
-            var params = if (args2.size > 1) args2[1] else ""
-            var command = commands[commandName]
-
-            if (command == null) {
-                // Assume user wants to talk to Cleverbot
-                command = commands["talk"]
-                if (command == null) {
-                    commandNotFound(event, commandName)
-                    return false
-                }
-                params = args[1]
-            }
-
-            val inputArguments = if (params == "") arrayOf<String>()
-            else params.split("\\s+".toRegex(), command.parameters.size).toTypedArray()
+        // @<mention> command from Minecraft
+        if (event is AsyncPlayerChatEventWrapper && event.rawMessage.startsWith("@${Config.USERNAME.noSpace()} ")) {
+            val split = event.rawMessage.replaceFirst("@${Config.USERNAME.noSpace()} ", "").trim().split("\\s+".toRegex()).toTypedArray()
+            return parseCommand(event, split, true)
+        }
 
-            return invokeCommand(command, controllers, event, inputArguments)
+        // @<mention> command from Discord
+        if (event is MessageWrapper && event.rawMessage.startsWith(Connection.JDA.selfUser.asMention + " ")) {
+            val split = event.rawMessage.replaceFirst(Connection.JDA.selfUser.asMention + " ", "").trim().split("\\s+".toRegex()).toTypedArray()
+            return parseCommand(event, split, true)
         }
 
-        // Just relay the message if it is neither
+        // Just relay the message if no command is found
         relay(event, true)
         return true
     }
@@ -156,7 +137,7 @@ class BotControllerManager(val plugin: Plugin) {
      * @param event the incoming event object
      * @return true if a trigger was found and successfully responded to, false otherwise
      */
-    private fun scriptedResponse(event: IEventWrapper): Boolean {
+    private fun sendScriptedResponse(event: IEventWrapper): Boolean {
         val responses = plugin.script.data.getList("responses").checkItemsAre<Script>() ?: return false
 
         var response: Script? = null
@@ -209,19 +190,50 @@ class BotControllerManager(val plugin: Plugin) {
     }
 
     /**
-     * Attempts to invoke a discovered command
+     * Attempt to parse and execute a command from an input string
+     *
+     * @param event the original event object
+     * @param args the input string broken up into an array of words, with the command as the first element
+     * @param defaultToTalk if true, failure to find a command to execute will execute Talk with Cleverbot using the
+     * full string as an argument. If false, failure will do nothing and the method call will return false.
+     */
+    private fun parseCommand(event: IEventWrapper, args: Array<String>, defaultToTalk: Boolean): Boolean {
+        val commandName = args[0].toLowerCase()
+        if (commandName == "") return true
+        var command = commands[commandName]
+
+        if (command == null) {
+            // Attempt to run as a server command if sent from Discord
+            if (event is MessageWrapper && event.originalMessage.member.hasPermission(Permission.ADMINISTRATOR))
+                if (invokeServerCommand(event, args)) return true
+
+            if (defaultToTalk) command = commands["talk"]
+            if (command == null) {
+                commandNotFound(event, commandName)
+                return false
+            }
+        }
+
+        val slicedArgs = if (args.size > 1) args.slice(1 until args.size).toTypedArray() else arrayOf()
+        return invokeBotCommand(command, controllers, event, slicedArgs)
+    }
+
+    /**
+     * Attempts to run a DiscordBridge command
      *
      * @param command the command to invoke
      * @param instances a map of IBotController instances accessed by their Java classes
      * @param event the incoming event object
-     * @param inputArguments an array of String arguments to pass to the command method
+     * @param args an array of String arguments to pass to the command method
      * @return false if the command invocation has invalid arguments, true otherwise
      */
-    private fun invokeCommand(command: Command, instances: Map<Class<out IBotController>, IBotController>,
-                              event: IEventWrapper, inputArguments: Array<String>): Boolean {
+    private fun invokeBotCommand(command: Command, instances: Map<Class<out IBotController>, IBotController>,
+                                 event: IEventWrapper, args: Array<String>): Boolean {
         // Relay the trigger if applicable
         if (command.relayTriggerMessage) relay(event, false)
 
+        var squishedArgs = args
+
         when {
             // Check for permission
             event is AsyncPlayerChatEventWrapper && !event.event.player.hasPermission("discordbridge.${command.name}") -> {
@@ -237,7 +249,7 @@ class BotControllerManager(val plugin: Plugin) {
             command.name == "help" -> {
                 try {
                     val response = command.commandMethod.invoke(instances[command.controllerClass], event, commands, instances) as? String ?: return true
-                    respond(event, command, response)
+                    sendBotCommandOutput(event, command, response)
                     return true
                 } catch (e: IllegalArgumentException) {
                     commandWrongParameterCount(event, command.name, command.usage, 2, command.parameters.size)
@@ -248,15 +260,19 @@ class BotControllerManager(val plugin: Plugin) {
                 }
             }
 
-            // Fail if not enough arguments
-            inputArguments.size < command.parameters.size -> {
-                commandWrongParameterCount(event, command.name, command.usage, inputArguments.size, command.parameters.size)
-                return false
+            // If command is squishy, pack excess args into final string
+            command.squishExcessArgs -> {
+                if (command.parameters.size == 1)
+                    squishedArgs = arrayOf(args.joinToString(" "))
+                else {
+                    squishedArgs = args.sliceArray(0 until command.parameters.size-1)
+                    squishedArgs[command.parameters.size-1] = args.sliceArray(command.parameters.size-1 until args.size).joinToString(" ")
+                }
             }
 
-            // Fail if command forces exact argument count AND the supplied argument count does not match expected
-            inputArguments.size != command.parameters.size && !command.ignoreExcessArguments -> {
-                commandWrongParameterCount(event, command.name, command.usage, inputArguments.size, command.parameters.size)
+            // Fail if wrong number of arguments
+            squishedArgs.size != command.parameters.size -> {
+                commandWrongParameterCount(event, command.name, command.usage, squishedArgs.size, command.parameters.size)
                 return false
             }
         }
@@ -264,15 +280,15 @@ class BotControllerManager(val plugin: Plugin) {
         // Package arguments to send to method
         val arguments = arrayOfNulls<Any>(command.parameters.size + 1)
         arguments[0] = event
-        val paramRange = if (command.ignoreExcessArguments && inputArguments.size > command.parameters.size)
+        val paramRange = if (command.squishExcessArgs && squishedArgs.size > command.parameters.size)
             IntRange(0, command.parameters.size - 1) else command.parameters.indices
         for (i in paramRange) {
             val parameterClass = command.parameters[i]
 
             try {
-                arguments[i + 1] = parseArgument(parameterClass, inputArguments[i])
+                arguments[i + 1] = parseArgument(parameterClass, squishedArgs[i])
             } catch (ignored: IllegalArgumentException) {
-                commandWrongParameterType(event, command.name, command.usage, i, inputArguments[i].javaClass, parameterClass)
+                commandWrongParameterType(event, command.name, command.usage, i, squishedArgs[i].javaClass, parameterClass)
                 return false
             }
         }
@@ -280,10 +296,10 @@ class BotControllerManager(val plugin: Plugin) {
         // Invoke the method
         try {
             val response = command.commandMethod.invoke(instances[command.controllerClass], *arguments) as? String ?: return true
-            respond(event, command, response)
+            sendBotCommandOutput(event, command, response)
             return true
         } catch (e: IllegalArgumentException) {
-            commandWrongParameterCount(event, command.name, command.usage, inputArguments.size, command.parameters.size)
+            commandWrongParameterCount(event, command.name, command.usage, squishedArgs.size, command.parameters.size)
             return false
         } catch (e: Exception) {
             commandException(event, e)
@@ -293,13 +309,13 @@ class BotControllerManager(val plugin: Plugin) {
     }
 
     /**
-     * Sends the response of a successful command invocation to its respective medium
+     * Sends the response of a successful bot command invocation to its respective medium
      *
      * @param event the incoming event object
      * @param command the command that was invoked
      * @param response the output string of the invoked command
      */
-    private fun respond(event: IEventWrapper, command: Command, response: String) {
+    private fun sendBotCommandOutput(event: IEventWrapper, command: Command, response: String) {
         var modifiedResponse = response
         when (event) {
             is AsyncPlayerChatEventWrapper -> {
@@ -353,6 +369,46 @@ class BotControllerManager(val plugin: Plugin) {
         }
     }
 
+    /**
+     * Attempts to run a Spigot command
+     *
+     * @param event the incoming event object
+     * @param args the arguments associated with the command, space-delimited
+     */
+    private fun invokeServerCommand(event: IEventWrapper, args: Array<String>): Boolean {
+            val sender = DiscordCommandSender(event.channel)
+            val commandName = args[0].toLowerCase()
+            when {
+                DefaultCommands.minecraft.contains(commandName) -> {
+                    plugin.logDebug("Discord user ${event.senderName} invoked Minecraft command '${args.joinToString(" ")}'")
+                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
+                    return true
+                }
+
+                DefaultCommands.bukkit.contains(commandName) -> {
+                    plugin.logDebug("Discord user ${event.senderName} invoked Bukkit command '${args.joinToString(" ")}'")
+                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
+                    return true
+                }
+
+                DefaultCommands.spigot.contains(commandName) -> {
+                    plugin.logDebug("Discord user ${event.senderName} invoked Spigot command '${args.joinToString(" ")}'")
+                    Bukkit.getServer().dispatchCommand(sender, args.joinToString(" "))
+                    return true
+                }
+
+                else -> {
+                    val pluginCommand = Bukkit.getServer().getPluginCommand(commandName)
+                    if (pluginCommand != null) {
+                        plugin.logDebug("Discord user ${event.senderName} invoked ${pluginCommand.plugin.name} command '${args.joinToString(" ")}'")
+                        pluginCommand.execute(sender, commandName, args.sliceArray(1 until args.size))
+                        return true
+                    }
+                }
+            }
+        return false
+    }
+
     /**
      * Attempts to relay the message between Minecraft and Discord, if applicable
      *
@@ -361,7 +417,6 @@ class BotControllerManager(val plugin: Plugin) {
      * message is not relayed to Minecraft
      */
     private fun relay(event: IEventWrapper, logIgnore: Boolean) {
-        plugin.logger.info("Entered relay. event: ${event.message}")
         when (event) {
             is AsyncPlayerChatEventWrapper -> {
                 var worldname = event.event.player.world.name
@@ -394,53 +449,8 @@ class BotControllerManager(val plugin: Plugin) {
         }
     }
 
-    /**
-     * Attempts to parse a string parameter to an expected value type
-     *
-     * @param parameterClass the expected type of the parameter
-     * @param value a string representation of the value to be parsed
-     */
-    private fun parseArgument(parameterClass: Class<*>, value: String): Any {
-        try {
-            when (parameterClass) {
-                String::class.java -> return value
-                Int::class.javaPrimitiveType, Int::class.java -> return Integer.valueOf(value)
-                Long::class.javaPrimitiveType, Long::class.java -> return java.lang.Long.valueOf(value)
-                Boolean::class.javaPrimitiveType, Boolean::class.java -> return parseBooleanArgument(value)
-                Float::class.javaPrimitiveType, Float::class.java -> return java.lang.Float.valueOf(value)
-                Double::class.javaPrimitiveType, Double::class.java -> return java.lang.Double.valueOf(value)
-                else -> throw IllegalArgumentException()
-            }
-        } catch (ignored: NumberFormatException) {
-            throw IllegalArgumentException()
-        }
-    }
-
-    /**
-     * Attempts to parse a string parameter to a Boolean type
-     *
-     * @param value a string representation of the value to be parsed
-     */
-    private fun parseBooleanArgument(value: String): Boolean {
-        when (value.toLowerCase()) {
-            "yes", "true" -> return true
-            "no", "false" -> return false
-            else -> {
-                val integerValue = Integer.valueOf(value)!!
-                when (integerValue) {
-                    1 -> return true
-                    0 -> return false
-                    else -> throw IllegalArgumentException()
-                }
-            }
-        }
-    }
-
-    /**
-     * A function to assert that all the items in a given list are of a specific type
-     */
-    @Suppress("UNCHECKED_CAST")
-    private inline fun <reified T : Any> List<*>.checkItemsAre() = if (all { it is T }) this as List<T> else null
+    // =============================================
+    // ============= Exception Handling ============
 
     /**
      * Handler for if command syntax is given but no matching command is found
@@ -568,11 +578,63 @@ class BotControllerManager(val plugin: Plugin) {
         }
     }
 
+    // =============================================
+    // ============== HELPER FUNCTIONS =============
+
+    /**
+     * Attempts to parse a string parameter to an expected value type
+     *
+     * @param parameterClass the expected type of the parameter
+     * @param value a string representation of the value to be parsed
+     */
+    private fun parseArgument(parameterClass: Class<*>, value: String): Any {
+        return try {
+            when (parameterClass) {
+                String::class.java -> value
+                Int::class.javaPrimitiveType, Int::class.java -> Integer.valueOf(value)
+                Long::class.javaPrimitiveType, Long::class.java -> java.lang.Long.valueOf(value)
+                Boolean::class.javaPrimitiveType, Boolean::class.java -> parseBooleanArgument(value)
+                Float::class.javaPrimitiveType, Float::class.java -> java.lang.Float.valueOf(value)
+                Double::class.javaPrimitiveType, Double::class.java -> java.lang.Double.valueOf(value)
+                else -> throw IllegalArgumentException()
+            }
+        } catch (ignored: NumberFormatException) {
+            throw IllegalArgumentException()
+        }
+    }
+
+    /**
+     * Attempts to parse a string parameter to a Boolean type
+     *
+     * @param value a string representation of the value to be parsed
+     */
+    private fun parseBooleanArgument(value: String): Boolean = when (value.toLowerCase()) {
+        "yes", "true" -> true
+        "no", "false" -> false
+        else -> {
+            val integerValue = Integer.valueOf(value)!!
+            when (integerValue) {
+                1 -> true
+                0 -> false
+                else -> throw IllegalArgumentException()
+            }
+        }
+    }
+
     /**
      * Shortcut method for adding "or <prefix>help " to the CommandNotFound output if a COMMAND_PREFIX is set in config
      */
     private fun orPrefixHelp(): String = if (Config.COMMAND_PREFIX != "") "or ${Config.COMMAND_PREFIX}help " else ""
 
+    /**
+     * A function to assert that all the items in a given list are of a specific type
+     */
+    @Suppress("UNCHECKED_CAST")
+    private inline fun <reified T : Any> List<*>.checkItemsAre() = if (all { it is T }) this as List<T> else null
+
+    // =============================================
+    // =============== HELPER OBJECTS ==============
+
     /**
      * Represents a command that the bot can execute
      *
@@ -581,7 +643,7 @@ class BotControllerManager(val plugin: Plugin) {
      * @param description a description of the command's function
      * @param parameters a List of the command arguments' expected Java class types
      * @param relayTriggerMessage whether the message that triggered this command should be relayed
-     * @param ignoreExcessArguments whether this command should ignore excess arguments
+     * @param squishExcessArgs whether this command should combine excess arguments into one
      * @param isTagged if the output of this command should be prepended with "@invokerName | "
      * @param isPrivate if the output of this command should be sent via DM/PM to the invoker
      * @param controllerClass the Java class type of the IBotController that defines this command
@@ -593,10 +655,101 @@ class BotControllerManager(val plugin: Plugin) {
             val description: String,
             val parameters: List<Class<*>>,
             val relayTriggerMessage: Boolean,
-            val ignoreExcessArguments: Boolean,
+            val squishExcessArgs: Boolean,
             val isTagged: Boolean,
             val isPrivate: Boolean,
             val controllerClass: Class<*>,
             val commandMethod: Method
     )
+
+    /**
+     * A simple list of all commands native to Minecraft, Bukkit, and Spigot
+     *
+     * TODO: Can this list be attained programmatically??
+     */
+    private object DefaultCommands {
+        val minecraft : List<String> = listOf(
+                "advancement",
+                "ban",
+                "blockdata",
+                "clear",
+                "clone",
+                //"data",
+                //"datapack",
+                "debug",
+                "defaultgamemode",
+                "deop",
+                "difficulty",
+                "effect",
+                "enchant",
+                "entitydata",
+                //"experience",
+                "execute",
+                "fill",
+                "function",
+                "gamemode",
+                "gamerule",
+                "give",
+                "help",
+                "kick",
+                "kill",
+                "list",
+                "locate",
+                "me",
+                "op",
+                "pardon",
+                "particle",
+                "playsound",
+                "publish",
+                "recipe",
+                "reload",
+                "replaceitem",
+                "save",
+                "say",
+                "scoreboard",
+                "seed",
+                "setblock",
+                "setidletimeout",
+                "setmaxplayers",
+                "setworldspawn",
+                "spawnpoint",
+                "spreadplayers",
+                "stats",
+                "stop",
+                "stopsound",
+                "summon",
+                "teleport",
+                "tell",
+                //"tag",
+                //"team",
+                "tellraw",
+                "testfor",
+                "testforblock",
+                "testforblocks",
+                "tickingarea",
+                "time",
+                "title",
+                "toggledownfall",
+                "tp",
+                "transferserver",
+                "trigger",
+                "weather",
+                "whitelist",
+                "worldborder",
+                "wsserver"
+        )
+
+        val bukkit : List<String> = listOf(
+                "version",
+                "plugins",
+                "help",
+                "reload",
+                "timings"
+        )
+
+        val spigot:List<String> = listOf(
+                "restart",
+                "tps"
+        )
+    }
 }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
index 1214aa5..0ca3c56 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/commands/controllers/FunCommandsController.kt
@@ -29,7 +29,7 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
      * @param event the incoming event object
      * @return the response string
      */
-    @BotCommand(name = "8ball", usage = "<question>", description = "Consult the Magic 8 Ball")
+    @BotCommand(name = "8ball", usage = "<question>", description = "Consult the Magic 8 Ball", squishExcessArgs = true)
     @TaggedResponse
     private fun eightBall(event: IEventWrapper): String {
         plugin.logDebug("user ${event.senderName} consults the Magic 8-Ball")
@@ -46,7 +46,7 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
      * @return the response string
      */
     @BotCommand(name = "choose", usage = "<option>, <option>, ... (delimiters include ',', 'or', '|')",
-            description = "Have the bot choose between given options")
+            description = "Have the bot choose between given options", squishExcessArgs = true)
     @TaggedResponse
     private fun choose(event: IEventWrapper, query: String): String {
         plugin.logDebug("user ${event.senderName} needs a choice made")
@@ -80,11 +80,11 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
 
         totalRespects += found!!.count
         val msg: String
-        if (found.message.contains("%u"))
-            msg = found.message.replace("%u", event.senderAsMention).replace("%t", totalRespects.toString())
-                .replace("%c", found.count.toString())
+        msg = if (found.message.contains("%u"))
+            found.message.replace("%u", event.senderAsMention).replace("%t", totalRespects.toString())
+                    .replace("%c", found.count.toString())
         else
-            msg = "${event.senderAsMention} | ${found.message}".replace("%t", totalRespects.toString())
+            "${event.senderAsMention} | ${found.message}".replace("%t", totalRespects.toString())
                     .replace("%c", found.count.toString())
 
         plugin.f.data.set("total-respects", totalRespects)
@@ -100,7 +100,7 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
      * @param thingToInsult the target of the insult
      * @return the response string
      */
-    @BotCommand(usage="<thing to insult>", description = "Make the bot insult something for you")
+    @BotCommand(usage="<thing to insult>", description = "Make the bot insult something for you", squishExcessArgs = true)
     private fun insult(event: IEventWrapper, thingToInsult: String): String {
         plugin.logDebug("user ${event.senderName} requests an insult against '$thingToInsult'")
         val responses = plugin.insult.data.getStringList("responses")
@@ -115,7 +115,7 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
      * @param thingToRate the thing that will receive the rating
      * @return the response string
      */
-    @BotCommand(usage="<thing to be rated>", description = "Have the bot rate something for you")
+    @BotCommand(usage="<thing to be rated>", description = "Have the bot rate something for you", squishExcessArgs = true)
     @TaggedResponse
     private fun rate(event: IEventWrapper, thingToRate: String): String {
         plugin.logDebug("user ${event.senderName} requests a rating")
@@ -182,13 +182,13 @@ class FunCommandsController(val plugin: Plugin) : IBotController {
      * @return the response string
      */
     @TaggedResponse
-    @BotCommand(usage="<say something>", description = "Say something to Cleverbot")
+    @BotCommand(usage="<say something>", description = "Say something to Cleverbot", squishExcessArgs = true)
     private fun talk(event: IEventWrapper, query: String): String {
         plugin.logDebug("user ${event.senderName} invokes Cleverbot")
 
         if (Config.CLEVERBOT_KEY.isEmpty())
             return "You do not have an API key. Go to https://www.cleverbot.com/JDA/ for more information."
-        val bot: CleverBotQuery = CleverBotQuery(Config.CLEVERBOT_KEY, query)
+        val bot = CleverBotQuery(Config.CLEVERBOT_KEY, query)
         bot.sendRequest()
         return bot.response
     }
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt b/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt
index 1c93493..d5b9295 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/discord/Connection.kt
@@ -15,7 +15,7 @@ import net.dv8tion.jda.core.entities.*
 object Connection: Runnable {
     lateinit var plugin: Plugin
     lateinit var JDA: JDA
-    lateinit var listener: Listener
+    private lateinit var listener: Listener
     var server: Guild? = null
     var channel: TextChannel? = null
 
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt b/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt
index adce7a5..e9b78a6 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/discord/Listener.kt
@@ -15,7 +15,7 @@ import net.dv8tion.jda.core.hooks.ListenerAdapter
  */
 class Listener(val plugin: Plugin) : ListenerAdapter() {
 
-    val controllerManager = BotControllerManager(plugin)
+    private val controllerManager = BotControllerManager(plugin)
 
     init {
         controllerManager.registerController(FunCommandsController(plugin), discordExclusive = true, chatExclusive = true)
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt
index ce806d9..7063646 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/CommandListener.kt
@@ -16,7 +16,7 @@ import org.bukkit.command.CommandSender
  */
 class CommandListener(val plugin: Plugin) : CommandExecutor {
 
-    val controllerManager = BotControllerManager(plugin)
+    private val controllerManager = BotControllerManager(plugin)
 
     init {
         controllerManager.registerController(FunCommandsController(plugin), minecraftExclusive = true)
diff --git a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
index 72c1c13..bdc4df2 100644
--- a/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
+++ b/src/main/kotlin/gg/obsidian/discordbridge/minecraft/EventListener.kt
@@ -31,7 +31,7 @@ import org.bukkit.ChatColor as CC
  */
 class EventListener(val plugin: Plugin): Listener {
 
-    val controllerManager = BotControllerManager(plugin)
+    private val controllerManager = BotControllerManager(plugin)
 
     init {
         controllerManager.registerController(FunCommandsController(plugin), chatExclusive = true)
@@ -73,7 +73,6 @@ class EventListener(val plugin: Plugin): Listener {
         plugin.server.scheduler.runTaskAsynchronously(plugin, { controllerManager.dispatchMessage(wrapper) })
 
         event.message = MarkdownToMinecraftSeralizer().toMinecraft(plugin.pegDownProc.parseMarkdown(event.message.toCharArray()))
-        plugin.logger.info("Seralized! (synchronous)")
     }
 
     /**