glassframe-protocol 2.0.0 → 2.1.0

package/dist/src/commands/PrefixRouter.js

@@ -1,16 +1,25 @@
 "use strict";
 
-const { buildPanel, buildMetricsMessage } = require("../ui/ControlPanel");
+const { buildPanel, buildMetricsMessage, buildEnginePage } = require("../ui/ControlPanel");
 const { buildLogMessage } = require("../logging/ComponentsV2");
 
-const LAYER_NAMES = ["antiRaid", "antiNuke", "basicSecurity", "aiModeration"];
-const COMMANDS = ["panel", "status", "help", "whitelist", "scan", "metrics", "phishing"];
+const COMMANDS = ["panel", "status", "help", "whitelist", "scan", "metrics", "phishing", "prefix", "engine"];
+const OWNER_ONLY_COMMANDS = new Set(["engine"]);
+
+const LAYER_REASONING = {
+  basicSecurity: "watches every message for spam, scam/phishing language, raid-recruitment language, and bad links.",
+  antiRaid: "watches joins for rate spikes, alt-account patterns, and account-creation clusters.",
+  antiNuke: "watches the audit log for destructive bursts, dangerous permission grants, and channel lockouts.",
+  aiModeration: "sends only ambiguous messages (not clean, not clearly bad) to Groq for a second opinion."
+};
 
 /**
  * GlassFrame Protocol registers no slash commands, by design (see
  * docs/COMMANDS.md). Every command here is a plain prefix command gated on
  * Manage Server permission, with a short per-user cooldown so a doubled
- * keypress can't fire the same command twice in a row.
+ * keypress can't fire the same command twice in a row. Each server can set
+ * its own prefix (`!gf prefix set`); the default from config.js always
+ * still works too, as a fallback.
  */
 class PrefixRouter {
   constructor(frame) {
@@ -32,16 +41,25 @@ class PrefixRouter {
     return false;
   }
 
+  /** Tries this server's custom prefix (if set) and the default, longer one first, so an overlapping pair resolves sensibly. */
+  _matchPrefix(message) {
+    const custom = this.frame.guildPrefixes.get(message.guild.id);
+    const candidates = [custom, this.frame.config.prefix].filter(Boolean).sort((a, b) => b.length - a.length);
+    return candidates.find((p) => message.content.toLowerCase().startsWith(p.toLowerCase())) || null;
+  }
+
   async _handle(message) {
     if (!message.guild || message.author.bot) return;
-    const prefix = this.frame.config.prefix;
-    if (!message.content.toLowerCase().startsWith(prefix.toLowerCase())) return;
+    const prefix = this._matchPrefix(message);
+    if (!prefix) return;
 
     const args = message.content.slice(prefix.length).trim().split(/\s+/);
     const command = (args.shift() || "").toLowerCase();
     if (!COMMANDS.includes(command)) return;
 
-    if (!this.frame.isAuthorized(message.member)) {
+    if (OWNER_ONLY_COMMANDS.has(command)) {
+      if (!this.frame.isOwner(message.author.id)) return; // silent - this command doesn't exist as far as non-owners can tell
+    } else if (!this.frame.isAuthorized(message.member)) {
       await message.reply({ content: "You need Manage Server permission to use GlassFrame Protocol commands." });
       return;
     }
@@ -55,6 +73,8 @@ class PrefixRouter {
     if (command === "scan") return this._scan(message);
     if (command === "metrics") return this._metrics(message);
     if (command === "phishing") return this._phishing(message, args);
+    if (command === "prefix") return this._prefix(message, args);
+    if (command === "engine") return this._engine(message, args);
   }
 
   async _panel(message) {
@@ -63,36 +83,56 @@ class PrefixRouter {
     this.frame.panelMessages.set(sent.id, message.guild.id);
   }
 
+  /** Each layer's line explains what it actually watches for, not just on/off - the same reasoning-first approach as metrics. */
   async _status(message) {
     const status = this.frame.getStatus(message.guild.id);
-    const fields = LAYER_NAMES.map((l) => ({ name: l, value: status[l] ? "ACTIVE" : "INACTIVE" }));
+    const fields = Object.keys(this.frame.layers).map((name) => ({
+      name: `${status[name] ? "ACTIVE" : "INACTIVE"} - ${name}`,
+      value: LAYER_REASONING[name] || "a custom layer registered via frame.registerLayer()."
+    }));
     const payload = buildLogMessage({ level: "info", title: "GlassFrame Protocol - Status", fields });
     await message.channel.send(payload);
   }
 
   async _help(message) {
-    const prefix = this.frame.config.prefix;
-    const payload = buildLogMessage({
-      level: "info",
-      title: "GlassFrame Protocol - Commands",
-      description: [
-        `${prefix}panel - open the 5-button control panel`,
-        `${prefix}status - show which layers are active`,
-        `${prefix}scan - check current roles for name/permission mismatches`,
-        `${prefix}metrics - this server's metrics (button on the message switches to global)`,
-        `${prefix}phishing add|remove|list <domain> - manage the link blocklist`,
-        `${prefix}whitelist add <userId> - exempt a user from punitive action in this server`,
-        `${prefix}whitelist remove <userId> - remove an exemption`,
-        `${prefix}help - this message`
-      ].join("\n")
-    });
+    const prefix = this.frame.getPrefix(message.guild.id);
+    const sections = [
+      {
+        name: "Getting started",
+        value: [
+          `${prefix}panel - the 5-button control panel. Nothing runs until a layer is armed here (or via autoStart in code).`,
+          `${prefix}status - which layers are on right now, and what each one actually watches for.`
+        ].join("\n")
+      },
+      {
+        name: "Security tools",
+        value: [
+          `${prefix}scan - checks current roles for name/permission mismatches (impersonation bait, quiet privilege grants).`,
+          `${prefix}phishing add|remove|list <domain> - manage the link blocklist Basic Security checks messages against.`,
+          `${prefix}whitelist add|remove <userId> - exempt someone from punitive action, in this server only.`
+        ].join("\n")
+      },
+      {
+        name: "Diagnostics",
+        value: `${prefix}metrics - this server's numbers (open cases, flagged members, whitelist size); one button on the message switches to bot-wide totals across every server.`
+      },
+      {
+        name: "Customization",
+        value: [
+          `${prefix}prefix set <newPrefix> - change this server's command prefix.`,
+          `${prefix}prefix reset - go back to the default (\`${this.frame.config.prefix}\`).`
+        ].join("\n")
+      }
+    ];
+    const payload = buildLogMessage({ level: "info", title: "GlassFrame Protocol - Help", fields: sections });
     await message.channel.send(payload);
   }
 
   async _whitelist(message, args) {
+    const prefix = this.frame.getPrefix(message.guild.id);
     const [sub, id] = args;
     if (!sub || !id) {
-      await message.reply({ content: `Usage: ${this.frame.config.prefix}whitelist <add|remove> <userId>` });
+      await message.reply({ content: `Usage: ${prefix}whitelist <add|remove> <userId>` });
       return;
     }
 
@@ -102,7 +142,7 @@ class PrefixRouter {
     else return;
 
     await message.reply({
-      content: `Whitelist updated: ${id} ${action === "add" ? "added to" : "removed from"} the exemption list.`
+      content: `Whitelist updated: ${id} ${action === "add" ? "added to" : "removed from"} the exemption list for this server.`
     });
   }
 
@@ -126,8 +166,8 @@ class PrefixRouter {
   }
 
   async _phishing(message, args) {
+    const prefix = this.frame.getPrefix(message.guild.id);
     const [sub, domain] = args;
-    const prefix = this.frame.config.prefix;
 
     if (!sub || sub.toLowerCase() === "list") {
       const domains = this.frame.phishingDatabase.list();
@@ -153,6 +193,60 @@ class PrefixRouter {
       await message.reply({ content: `Usage: ${prefix}phishing <add|remove|list> <domain>` });
     }
   }
+
+  async _prefix(message, args) {
+    const [sub, newPrefix] = args;
+    const current = this.frame.getPrefix(message.guild.id);
+
+    if (!sub) {
+      await message.reply({ content: `This server's prefix is currently \`${current}\`. Usage: ${current}prefix set <newPrefix> | reset` });
+      return;
+    }
+
+    const action = sub.toLowerCase();
+    if (action === "reset") {
+      this.frame.guildPrefixes.delete(message.guild.id);
+      this.frame._persistGuildState(message.guild.id);
+      await message.reply({ content: `Prefix reset to the default: \`${this.frame.config.prefix}\`` });
+      return;
+    }
+
+    if (action === "set") {
+      if (!newPrefix) {
+        await message.reply({ content: `Usage: ${current}prefix set <newPrefix>` });
+        return;
+      }
+      this.frame.setPrefix(message.guild.id, newPrefix);
+      await message.reply({
+        content: `This server's prefix is now \`${newPrefix}\`. The default \`${this.frame.config.prefix}\` still works too, as a fallback.`
+      });
+      return;
+    }
+
+    await message.reply({ content: `Usage: ${current}prefix set <newPrefix> | reset` });
+  }
+
+  /**
+   * Owner-only, bot-wide dashboard - see frame.getEngineReport(). Not
+   * listed in !gf help on purpose. If config.engine.password is set, it's
+   * required as `!gf engine <password>`; the command message is deleted
+   * either way (right or wrong) so the password never sits visible in
+   * channel history. Wrong-password attempts count toward a lockout - see
+   * GlassFrame.verifyEnginePassword().
+   */
+  async _engine(message, args) {
+    const passwordOk = this.frame.verifyEnginePassword(message.author.id, args.join(" "));
+    try {
+      if (message.deletable) await message.delete();
+    } catch {
+      /* best effort - if the bot can't delete here, that's a permissions gap to fix, not a reason to fail open */
+    }
+    if (!passwordOk) return;
+
+    const report = this.frame.getEngineReport();
+    const payload = buildEnginePage(report, "overview");
+    await message.channel.send(payload);
+  }
 }
 
 module.exports = PrefixRouter;

package/dist/src/core/PerformanceMonitor.js

@@ -3,19 +3,31 @@
 /**
  * Lightweight internal metrics collector - no external dependency, no
  * network call, just counters and a small rolling latency sample per event
- * type. Exposed via `frame.getMetrics()` / `!gf metrics` so you can see
- * whether the protocol is keeping up on a busy server without wiring in a
- * separate APM tool.
+ * type, plus a lightweight per-guild activity tally. Exposed via
+ * `frame.getMetrics()` / `!gf metrics` (per-server and bot-wide) and the
+ * owner-only `!gf engine` dashboard, so you can see whether the protocol is
+ * keeping up - and which server is generating the most work - without
+ * wiring in a separate APM tool.
  */
 class PerformanceMonitor {
   constructor() {
     this.startedAt = Date.now();
     this.eventCounts = {};
     this.latencies = {}; // name -> last 50 durations in ms
+    this.guildActivity = new Map(); // guildId -> event count since startup
   }
 
-  recordEvent(name) {
+  /** `guildId` is optional - pass it from any per-guild handler to also tally that guild's activity. */
+  recordEvent(name, guildId) {
     this.eventCounts[name] = (this.eventCounts[name] || 0) + 1;
+    if (guildId) {
+      this.guildActivity.set(guildId, (this.guildActivity.get(guildId) || 0) + 1);
+    }
+  }
+
+  /** Guild IDs ranked by recorded activity, busiest first. */
+  topGuildsByActivity(limit = 5) {
+    return [...this.guildActivity.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);
   }
 
   /** Call at the start of a unit of work; call the returned function when it finishes. */

package/dist/src/core/VersionInfo.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const VERSION = "2.0.0";
+const VERSION = "2.1.0";
 const NAME = "GlassFrame Protocol";
 const RELEASED = "2026-07-31";
 

package/dist/src/layers/AIModerationLayer.js

@@ -43,6 +43,7 @@ class AIModerationLayer extends Layer {
     if (!message.guild || message.author.bot || !message.content) return;
     if (!this.isEnabled(message.guild.id)) return;
     if (!this.groq?.available) return;
+    this.frame.performance.recordEvent("aiModeration.messageCreate", message.guild.id);
 
     const cfg = this.config;
     const local = classifyMessage(message.content);

package/dist/src/layers/AntiNukeLayer.js

@@ -19,7 +19,10 @@ const EVENT_MAP = {
   [AuditLogEvent.EmojiCreate]: "emojiCreate",
   [AuditLogEvent.EmojiDelete]: "emojiDelete",
   [AuditLogEvent.StickerCreate]: "stickerCreate",
-  [AuditLogEvent.StickerDelete]: "stickerDelete"
+  [AuditLogEvent.StickerDelete]: "stickerDelete",
+  [AuditLogEvent.MemberRoleUpdate]: "memberRoleUpdate",
+  [AuditLogEvent.ChannelOverwriteCreate]: "channelOverwriteCreate",
+  [AuditLogEvent.ChannelOverwriteUpdate]: "channelOverwriteUpdate"
 };
 
 class AntiNukeLayer extends Layer {
@@ -69,7 +72,7 @@ class AntiNukeLayer extends Layer {
     const type = EVENT_MAP[entry.action];
     if (!type) return;
     if (!this.isEnabled(guild.id)) return;
-    this.frame.performance.recordEvent(`antiNuke.auditEntry.${type}`);
+    this.frame.performance.recordEvent(`antiNuke.auditEntry.${type}`, guild.id);
 
     const executor = entry.executor;
     if (!executor || executor.id === this.client.user.id) return;
@@ -85,6 +88,12 @@ class AntiNukeLayer extends Layer {
     if (type === "inviteCreate" && this.config.watchInviteAbuse) {
       await this._checkInviteAbuse(entry, guild, executor);
     }
+    if (type === "memberRoleUpdate" && this.config.watchDangerousGrants) {
+      await this._checkMemberRoleGrant(entry, guild, executor);
+    }
+    if ((type === "channelOverwriteCreate" || type === "channelOverwriteUpdate") && this.config.watchOverwriteAbuse) {
+      await this._checkChannelOverwriteAbuse(entry, guild, executor);
+    }
     if (type === "webhookCreate" && this.config.webhookAbuse.enabled) {
       this.recentWebhooks.set(
         entry.targetId,
@@ -93,11 +102,10 @@ class AntiNukeLayer extends Layer {
       );
     }
 
-    // Invite creation doesn't count toward the generic burst threshold below -
-    // a legitimate server creates invites routinely, so it's special-cased
-    // above (and only escalated for non-staff + unrestricted configs)
-    // instead of contributing to a raw count.
-    if (type === "inviteCreate") return;
+    // These are special-cased above instead of contributing to a raw burst
+    // count - a single grant/overwrite change is worth flagging immediately
+    // on its own merits, not after N repeats.
+    if (type === "inviteCreate" || type === "memberRoleUpdate" || type === "channelOverwriteCreate" || type === "channelOverwriteUpdate") return;
 
     const count = this._record(guild.id, executor.id, type);
     const threshold = this.config.thresholds[type];
@@ -138,6 +146,7 @@ class AntiNukeLayer extends Layer {
     const role = guild.roles.cache.get(entry.targetId);
 
     await this.frame.logger.log(guild, {
+      layer: this.name,
       level: "alert",
       title: "Dangerous Permission Grant Detected",
       description: `${executor.tag} granted **${gained.join(", ")}** to role ${role ? role.name : entry.targetId}.`,
@@ -162,6 +171,7 @@ class AntiNukeLayer extends Layer {
     if (!changed.length) return;
 
     await this.frame.logger.log(guild, {
+      layer: this.name,
       level: "warn",
       title: "Server Identity Changed",
       description: `${executor.tag} changed: ${changed.map((c) => c.key).join(", ")}.`,
@@ -193,6 +203,7 @@ class AntiNukeLayer extends Layer {
     if (trust === "HIGH" || trust === "PROTECTED") return;
 
     await this.frame.logger.log(guild, {
+      layer: this.name,
       level: "warn",
       title: "Unrestricted Invite Created By Non-Staff Member",
       description: `${executor.tag} (trust: ${trust}) created an invite with no expiry and no use limit.`,
@@ -200,6 +211,86 @@ class AntiNukeLayer extends Layer {
     });
   }
 
+  /**
+   * RoleUpdate (above) catches a role's own permissions changing - this
+   * catches the other half: a specific MEMBER being handed a role that
+   * already carries dangerous permissions. Missing this meant someone
+   * with ManageRoles could quietly promote themselves (or an accomplice)
+   * without ever touching a role's definition.
+   */
+  async _checkMemberRoleGrant(entry, guild, executor) {
+    const added = (entry.changes || []).find((c) => c.key === "$add");
+    if (!added || !Array.isArray(added.new) || !added.new.length) return;
+
+    const dangerous = this.frame.config.roleAnalysis.dangerousPermissions;
+    const dangerousRoles = added.new
+      .map((r) => guild.roles.cache.get(r.id))
+      .filter((role) => role && dangerous.some((p) => role.permissions.has(PermissionsBitField.Flags[p])));
+    if (!dangerousRoles.length) return;
+
+    let executorMember = null;
+    try {
+      executorMember = await guild.members.fetch(executor.id);
+    } catch {
+      /* left already */
+    }
+    const trust = executorMember ? this.frame.roleAnalyzer.trustLevel(executorMember) : "LOW";
+    if (trust === "HIGH" || trust === "PROTECTED") return;
+
+    await this.frame.logger.log(guild, {
+      layer: this.name,
+      level: "alert",
+      title: "Dangerous Role Granted To A Member",
+      description: `${executor.tag} (trust: ${trust}) gave <@${entry.targetId}> the role(s): ${dangerousRoles
+        .map((r) => r.name)
+        .join(", ")}.`,
+      dedupeKey: `antinuke:member-grant:${entry.targetId}`
+    });
+  }
+
+  /**
+   * A nuke doesn't have to delete anything - locking @everyone out of a
+   * public channel, or opening a private one up to @everyone, does the
+   * same damage through permission overwrites instead. Only @everyone's
+   * own overwrite is watched here; a role- or member-specific overwrite
+   * change is routine channel administration and not worth flagging.
+   */
+  async _checkChannelOverwriteAbuse(entry, guild, executor) {
+    if (!entry.extra || String(entry.extra.id) !== guild.id) return;
+
+    const allowChange = (entry.changes || []).find((c) => c.key === "allow");
+    const denyChange = (entry.changes || []).find((c) => c.key === "deny");
+    if (!allowChange && !denyChange) return;
+
+    const oldAllow = new PermissionsBitField(BigInt(allowChange?.old ?? 0));
+    const newAllow = new PermissionsBitField(BigInt(allowChange?.new ?? 0));
+    const oldDeny = new PermissionsBitField(BigInt(denyChange?.old ?? 0));
+    const newDeny = new PermissionsBitField(BigInt(denyChange?.new ?? 0));
+
+    const view = PermissionsBitField.Flags.ViewChannel;
+    const nowGrantsView = !oldAllow.has(view) && newAllow.has(view);
+    const nowBlocksView = !oldDeny.has(view) && newDeny.has(view);
+    if (!nowGrantsView && !nowBlocksView) return;
+
+    let executorMember = null;
+    try {
+      executorMember = await guild.members.fetch(executor.id);
+    } catch {
+      /* left already */
+    }
+    const trust = executorMember ? this.frame.roleAnalyzer.trustLevel(executorMember) : "LOW";
+    if (trust === "HIGH" || trust === "PROTECTED") return;
+
+    const channel = guild.channels.cache.get(entry.targetId);
+    await this.frame.logger.log(guild, {
+      layer: this.name,
+      level: "alert",
+      title: nowBlocksView ? "Channel Locked Out For Everyone" : "Private Channel Opened To Everyone",
+      description: `${executor.tag} (trust: ${trust}) changed @everyone's access to ${channel ? channel.name : entry.targetId}.`,
+      dedupeKey: `antinuke:overwrite:${entry.targetId}`
+    });
+  }
+
   /**
    * Webhook messages never carry a guild member, so BasicSecurityLayer's
    * per-author spam buffer can't see them - a "create webhook, then flood
@@ -232,6 +323,7 @@ class AntiNukeLayer extends Layer {
     }
 
     await this.frame.logger.log(guild, {
+      layer: this.name,
       level: "alert",
       title: "Webhook Message Flood - Webhook Removed",
       description: `A recently created webhook sent ${list.length}+ messages inside ${cfg.windowMs / 1000}s and has been deleted.`,
@@ -271,6 +363,7 @@ class AntiNukeLayer extends Layer {
     if (!flags.length) return;
 
     await this.frame.logger.log(guild, {
+      layer: this.name,
       level: "warn",
       title: "Role Audit - Possible Impersonation/Permission Mismatch",
       description: flags.map((f) => `**${f.name}** (${f.roleId}) - ${f.reason}`).join("\n"),

package/dist/src/layers/AntiRaidLayer.js

@@ -71,7 +71,7 @@ class AntiRaidLayer extends Layer {
   async _handleJoin(member) {
     const { guild, user } = member;
     if (!this.isEnabled(guild.id)) return;
-    this.frame.performance.recordEvent("antiRaid.guildMemberAdd");
+    this.frame.performance.recordEvent("antiRaid.guildMemberAdd", guild.id);
     const joinCount = this._recordJoin(guild.id);
     const { score: altScore, entropyCheck } = this._altScore(user);
     const cluster = this._clusterScore(guild.id, user);
@@ -106,6 +106,7 @@ class AntiRaidLayer extends Layer {
     }
 
     await this.frame.logger.log(guild, {
+      layer: this.name,
       level: "alert",
       title: "Raid Detected - Lockdown Engaged",
       description: `${joinCount} joins inside ${this.config.joinWindowMs / 1000}s. Verification level temporarily raised.`,
@@ -129,6 +130,7 @@ class AntiRaidLayer extends Layer {
     }
 
     await this.frame.logger.log(guild, {
+      layer: this.name,
       level: "ok",
       title: "Lockdown Lifted",
       description: "Join activity normalized. Verification level restored.",

package/dist/src/layers/BasicSecurityLayer.js

@@ -25,7 +25,7 @@ class BasicSecurityLayer extends Layer {
     if (!message.guild || message.author.bot) return;
     if (!this.isEnabled(message.guild.id)) return;
     const done = this.frame.performance.time("basicSecurity.messageCreate");
-    this.frame.performance.recordEvent("basicSecurity.messageCreate");
+    this.frame.performance.recordEvent("basicSecurity.messageCreate", message.guild.id);
 
     const cfg = this.config;
     const buf = this._bufferFor(message.guild.id, message.author.id);
@@ -43,6 +43,8 @@ class BasicSecurityLayer extends Layer {
     const mentionCount = message.mentions.users.size + message.mentions.roles.size;
     const classification = classifyMessage(message.content || "");
     const linkFlag = this._checkLinks(message.content || "");
+    const hasInvite = this._checkInviteLink(message.content || "");
+    const trust = this.frame.roleAnalyzer.trustLevel(message.member);
 
     const reasons = [];
     let weight = 0;
@@ -59,6 +61,14 @@ class BasicSecurityLayer extends Layer {
       reasons.push(`mention spam (${mentionCount})`);
       weight += 25;
     }
+    // A single @everyone/@here reaches every member at once - much higher
+    // impact than several individual mentions, so it's weighted heavier and
+    // checked separately. Recognized trusted staff are exempt, since a real
+    // admin's announcement ping is routine, not an attack.
+    if (message.mentions.everyone && trust !== "HIGH" && trust !== "PROTECTED") {
+      reasons.push("@everyone/@here mention from a non-trusted member");
+      weight += 50;
+    }
     if (classification.scam >= cfg.nlp.scamScoreThreshold) {
       reasons.push(`scam language (${classification.scam.toFixed(2)})`);
       weight += 35;
@@ -67,6 +77,20 @@ class BasicSecurityLayer extends Layer {
       reasons.push(`phishing language (${classification.phishing.toFixed(2)})`);
       weight += 35;
     }
+    if (classification.raidCallout >= cfg.nlp.raidCalloutThreshold) {
+      reasons.push(`raid-recruitment language (${classification.raidCallout.toFixed(2)})`);
+      weight += 35;
+    }
+    // The specific pattern in a lot of real raid-tool spam: an invite link
+    // to another server, paired with language recruiting people to raid
+    // with it. Neither signal alone is damning - plenty of normal messages
+    // share an invite, plenty of normal messages mention "raid" in passing
+    // - but together, from a non-trusted member, it's a strong, specific
+    // signal worth weighting heavily on its own.
+    if (hasInvite && classification.raidCallout >= cfg.nlp.raidCalloutThreshold && trust !== "HIGH" && trust !== "PROTECTED") {
+      reasons.push("Discord invite link paired with raid-recruitment language");
+      weight += 50;
+    }
     if (linkFlag) {
       reasons.push(linkFlag);
       weight += 30;
@@ -104,6 +128,11 @@ class BasicSecurityLayer extends Layer {
     }
     return null;
   }
+
+  /** True if the message contains a Discord server invite link, of any of the URL forms Discord accepts. */
+  _checkInviteLink(text) {
+    return /(?:discord\.gg|discord(?:app)?\.com\/invite)\/[a-z0-9-]+/i.test(text);
+  }
 }
 
 module.exports = BasicSecurityLayer;

package/dist/src/logging/SmartLogger.js

@@ -2,12 +2,23 @@
 
 const { buildLogMessage } = require("./ComponentsV2");
 
+const RECENT_LOG_LIMIT = 30;
+
 /**
  * Every GlassFrame alert goes through one gate that:
  *  (a) merges near-duplicate events inside a short window into a single,
- *      updated message instead of one message per event, and
+ *      updated message instead of one message per event,
  *  (b) never sends to a guild's log channel faster than a configured floor,
- * so a burst never turns into a wall of messages or a Discord 429.
+ *      so a burst never turns into a wall of messages or a Discord 429, and
+ *  (c) keeps a small in-memory record of the most recent events across
+ *      EVERY guild, for the owner-only `!gf engine` dashboard - see
+ *      getRecentLogs() below.
+ *
+ * `getLogChannel(guild, layerName)` receives the reporting layer's name as
+ * an optional second argument, so you can route different layers to
+ * different channels if you want. A `getLogChannel` that only takes one
+ * parameter (the common case) keeps working unchanged - JS simply ignores
+ * the extra argument.
  */
 class SmartLogger {
   constructor(getLogChannel, config, { debug = false } = {}) {
@@ -16,10 +27,12 @@ class SmartLogger {
     this.debug = debug;
     this.pending = new Map(); // dedupeKey -> { count, payload, sent }
     this.lastSend = new Map(); // guildId -> timestamp
+    this.recentLogs = []; // bounded ring buffer, newest first - see getRecentLogs()
   }
 
   async log(guild, payload) {
     const key = payload.dedupeKey ? `${guild.id}:${payload.dedupeKey}` : null;
+    this._recordRecent(guild, payload);
 
     if (key && this.pending.has(key)) {
       const entry = this.pending.get(key);
@@ -56,7 +69,7 @@ class SmartLogger {
 
   async _deliver(guild, payload, count) {
     await this._respectRateFloor(guild.id);
-    const channel = await this.getLogChannel(guild);
+    const channel = await this.getLogChannel(guild, payload.layer);
     if (!channel) return null;
 
     const message = buildLogMessage({ ...payload, count });
@@ -76,6 +89,23 @@ class SmartLogger {
     if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
   }
 
+  _recordRecent(guild, payload) {
+    this.recentLogs.unshift({
+      at: Date.now(),
+      guildId: guild.id,
+      guildName: guild.name,
+      level: payload.level || "info",
+      title: payload.title || "",
+      layer: payload.layer || null
+    });
+    if (this.recentLogs.length > RECENT_LOG_LIMIT) this.recentLogs.length = RECENT_LOG_LIMIT;
+  }
+
+  /** The most recent log events across every guild, newest first - powers the owner-only `!gf engine` command. */
+  getRecentLogs(limit = 10) {
+    return this.recentLogs.slice(0, limit);
+  }
+
   _debug(msg) {
     if (this.debug) console.log(`[GlassFrame:SmartLogger] ${msg}`);
   }

package/dist/src/moderation/PunishmentEngine.js

@@ -5,8 +5,11 @@ const ProtocolCache = require("../core/Cache");
 
 // Used only to decide whether continued bad behavior mid-case deserves a
 // stronger response - never to decide the response itself (_decideAction
-// still owns that, trust-gating included).
+// still owns that, trust-gating included). Custom actions (registerAction)
+// default to 2 - the same tier as quarantine/timeout - since there's no
+// way to know their real severity automatically.
 const ACTION_SEVERITY = { log: 0, alert: 1, quarantine: 2, timeout: 2, kick: 3, ban: 4 };
+const severityOf = (action) => ACTION_SEVERITY[action] ?? 2;
 
 /**
  * The only place in GlassFrame Protocol that actually punishes a member.
@@ -18,12 +21,16 @@ const ACTION_SEVERITY = { log: 0, alert: 1, quarantine: 2, timeout: 2, kick: 3,
  * ladder alone would say.
  */
 class PunishmentEngine extends EventEmitter {
-  constructor({ config, threatEngine, roleAnalyzer, logger, whitelist, queue, performance, debug = false }) {
+  constructor({ config, threatEngine, roleAnalyzer, logger, whitelist, customActions, queue, performance, debug = false }) {
     super();
     this.config = config.punishment;
     this.threatEngine = threatEngine;
     this.roleAnalyzer = roleAnalyzer;
     this.logger = logger;
+    // actionName -> async (member, record) => void, registered via
+    // frame.registerAction() so config.punishment.ladder can reference
+    // custom actions beyond ban/kick/timeout/quarantine.
+    this.customActions = customActions || new Map();
     // Actual Discord mutations (ban/kick/timeout/quarantine) go through this
     // bounded-concurrency queue rather than firing directly, so a burst of
     // simultaneous cases (a raid, a nuke sweep) can't overrun Discord's rate
@@ -67,7 +74,7 @@ class PunishmentEngine extends EventEmitter {
 
       const trust = this.roleAnalyzer.trustLevel(member);
       const nextAction = this._decideAction(tier, trust);
-      if (ACTION_SEVERITY[nextAction] > ACTION_SEVERITY[openCase.action]) {
+      if (severityOf(nextAction) > severityOf(openCase.action)) {
         openCase.action = nextAction;
         openCase.trust = trust;
         this.cases.set(key, openCase);
@@ -125,6 +132,9 @@ class PunishmentEngine extends EventEmitter {
         const removable = member.roles.cache.filter((r) => r.id !== guild.id && r.editable);
         await this.queue.push(() => member.roles.remove(removable, this._reason(record)));
         performed = true;
+      } else if (this.customActions.has(action) && canAct) {
+        await this.queue.push(() => this.customActions.get(action)(member, record));
+        performed = true;
       }
     } catch (err) {
       record.error = err.message;
@@ -141,6 +151,7 @@ class PunishmentEngine extends EventEmitter {
     await this.logger.log(guild, {
       level: action === "alert" ? "alert" : action === "log" ? "info" : "warn",
       title: this._title(action),
+      layer: "punishmentEngine",
       description: `${member.user.tag} (${member.id}) - tier **${record.tier}**, trust **${record.trust}**.`,
       fields: [
         { name: "Reasons", value: record.reasons.slice(-5).join("\n") },