glassframe-protocol 1.2.1 → 2.0.0

package/CHANGELOG.md

@@ -14,6 +14,90 @@ lives in `src/core/VersionInfo.js` (`VersionInfo.info()` /
 `VersionInfo.banner()`), so code can read the current version without
 parsing this file.
 
+## [2.0.0] - 2026-08-01
+
+**Breaking.** Layer activation and the whitelist were accidentally global
+across every server the bot is in - this release makes them per-guild, the
+way they were always supposed to work, and adds real state persistence.
+
+### Fixed (breaking)
+
+- **Layer on/off state is now per-guild.** Previously, `Layer.enabled` was
+  one shared boolean - arming AntiRaid from one server's control panel
+  silently armed it for *every* server the bot serves. `getStatus(guildId)`
+  accepted a `guildId` but never actually used it. Both are now genuinely
+  per-guild: `Layer.enabledGuilds` is a `Set<guildId>`, and
+  `frame.enableLayer(name, guildId)` / `frame.disableLayer(name, guildId)`
+  now **require** a `guildId` argument. Calling either without one throws,
+  rather than silently doing the wrong thing.
+- **The whitelist is now per-guild.** `frame.whitelist` was a single global
+  `Set<userId>` - whitelisting someone in one server exempted them
+  everywhere. It's now a `Map<guildId, Set<userId>>`; use the new
+  `frame.addToWhitelist(guildId, userId)`,
+  `frame.removeFromWhitelist(guildId, userId)`, and
+  `frame.isWhitelisted(guildId, userId)` instead of touching the Map
+  directly. The constructor's `whitelist: [...]` option still works exactly
+  as before from the outside - it now seeds that list into every guild
+  (present and future) the first time GlassFrame sees it, rather than
+  applying globally.
+- **State now actually persists.** `stateStore` was constructed and then
+  never read from or written to anywhere. Every layer toggle and whitelist
+  change is now saved per-guild, and restored at startup (and automatically
+  for any new guild the bot joins) - see `docs/STATE.md`.
+- Fixed a related bug in `BasicSecurityLayer`: its spam-rate buffer was
+  keyed by `userId` alone, so the same user active in two different
+  servers could incorrectly share one rate-limit window. Now keyed by
+  `guildId:userId`.
+
+### Migrating from 1.x
+
+**If you only use the built-in control panel and `!gf` commands, nothing in
+your bot's code needs to change** - update the package and you're done; the
+panel and commands already operate within a specific server, they just
+didn't respect that internally before now.
+
+**If your own code calls these directly, update the call sites:**
+
+| 1.x | 2.0.0 |
+|---|---|
+| `frame.enableLayer(name)` | `frame.enableLayer(name, guildId)` |
+| `frame.disableLayer(name)` | `frame.disableLayer(name, guildId)` |
+| `frame.whitelist.add(userId)` | `frame.addToWhitelist(guildId, userId)` |
+| `frame.whitelist.delete(userId)` | `frame.removeFromWhitelist(guildId, userId)` |
+| `frame.whitelist.has(userId)` | `frame.isWhitelisted(guildId, userId)` |
+| `layer.enabled` | `layer.isEnabled(guildId)` |
+
+`options.autoStart` in the constructor is unchanged - still a plain array
+of layer names - but now correctly applies per-guild (to every guild the
+bot is already in, and automatically to any new one it joins) instead of
+turning a layer on everywhere at once.
+
+### Added
+
+- `frame.ready` - a Promise that resolves once every guild the bot was
+  already in at construction time has finished restoring its saved state.
+  State restoration is async (a real `stateStore` may hit disk/a database),
+  so this exists for anyone who wants an explicit guarantee rather than
+  relying on the fact that, in practice, it resolves faster than any
+  Discord event could arrive.
+- `frame.getGuildMetrics(guildId)` - one server's layer status, whitelist
+  size, open-case count, and flagged-member count.
+- `!gf metrics` now shows **this server's** numbers by default instead of
+  bot-wide totals, with one button on the message to switch to the global
+  (all-servers) view and back. This is a second button, separate from the
+  5-button panel - the panel is still exactly 5 buttons; the metrics
+  command now has 1 of its own.
+- `ProtocolCache.countByPrefix(prefix)` - powers the per-guild counts above
+  by counting non-expired `guildId:userId`-keyed entries for one guild.
+- `docs/STATE.md` - the per-guild state and persistence model in full.
+
+## [1.2.1] - 2026-07-31
+
+### Added
+
+- `homepage` and `discord` fields in `package.json` linking to the docs site
+  and the support server.
+
 ## [1.2.0] - 2026-07-31
 
 Packaging and licensing changes to make this publishable to npm. No

package/GETTING_STARTED.md

@@ -79,9 +79,10 @@ toggle gets reported there through Components V2 messages.
 
 Two ways, pick either or both:
 
-- **Code**: list layer names in `autoStart` (see Step 2), or call
-  `frame.enableLayer("antiNuke")` / `frame.disableLayer("antiNuke")`
-  anywhere after construction.
+- **Code**: list layer names in `autoStart` (see Step 2) - applies to every
+  server by default - or call
+  `frame.enableLayer("antiNuke", guildId)` / `frame.disableLayer("antiNuke", guildId)`
+  for one specific server anywhere after construction.
 - **In Discord**: an admin (Manage Server permission) sends `!gf panel` and
   gets 5 buttons - Activate/Deactivate AntiRaid, AI Moderation, AntiNuke,
   Basic Security, and Full Protocol (all four at once). This is the only
@@ -119,13 +120,14 @@ Nobody needs this guide again after setup. Server admins use:
 | `!gf scan` | Checks current roles for name/permission mismatches |
 | `!gf metrics` | Performance and cache health |
 | `!gf phishing add/remove/list <domain>` | Manage the link blocklist |
-| `!gf whitelist add/remove <userId>` | Exempt a user from punitive action |
+| `!gf whitelist add/remove <userId>` | Exempt a user from punitive action in this server |
 | `!gf help` | Lists all of the above |
 
 ## Going deeper
 
 - `README.md` - full feature overview
 - `docs/PROTOCOL_LAYERS.md` - how a signal becomes an action
+- `docs/STATE.md` - per-server layer/whitelist state and persistence
 - `docs/CACHE_ARCHITECTURE.md` - every internal cache and its TTL
 - `docs/PERFORMANCE.md` - the bounded-concurrency queues and `!gf metrics`
 - `docs/COMMANDS.md` - full command/button reference

package/README.md

@@ -7,18 +7,23 @@ pipeline instead of each reacting on its own, so the same member never gets
 hit by four different modules for one incident, and a single soft flag
 never turns into an auto-ban.
 
+Everything is per-server: one bot process can run GlassFrame across many
+Discord servers, each with its own independent set of active layers and its
+own whitelist, persisted across restarts. See `docs/STATE.md`.
+
 No slash commands - prefix commands only. No legacy `EmbedBuilder` - every
 log message renders through Discord's Components V2 system. No emoji
 anywhere in code or output.
 
 ## Install
 
-Copy the `glassframe-protocol` folder into your bot project, then:
-
 ```
-npm install
+npm install glassframe-protocol
 ```
 
+Or copy the `glassframe-protocol` folder directly into your bot project and
+`npm install` inside it - either works the same way.
+
 Requires `discord.js` v14.16+ (Components V2 support and the
 `guildAuditLogEntryCreate` event) and Node.js 18+ (global `fetch`, used only
 by the optional AI layer).
@@ -56,8 +61,8 @@ client.once("ready", () => {
   const frame = new GlassFrame(client, {
     getLogChannel: async (guild) =>
       guild.channels.cache.find((c) => c.name === "security-logs") ?? null,
-    whitelist: ["123456789012345678"],
-    autoStart: ["basicSecurity"], // layers not listed here start OFF until armed from the panel
+    whitelist: ["123456789012345678"], // trusted everywhere, seeded into every guild on first run
+    autoStart: ["basicSecurity"], // starting layers for every guild - not a global on/off
     config: {
       antiRaid: { joinThreshold: 8 },
       aiModeration: { apiKeys: [process.env.GROQ_KEY_1, process.env.GROQ_KEY_2].filter(Boolean) }
@@ -97,18 +102,20 @@ the 5-button control panel and arm layers from there instead of in code.
   cooldown on rate limits. See `config.aiModeration` and
   `docs/CACHE_ARCHITECTURE.md` for how verdicts get cached and keys rotated.
 
-Every layer starts disabled. Nothing runs until you list it in
-`autoStart`, call `frame.enableLayer(name)`, or arm it from the control
-panel.
+Every layer starts disabled, per guild. Nothing runs until you list it in
+`autoStart`, call `frame.enableLayer(name, guildId)`, or arm it from the
+control panel.
 
 ## Performance under load
 
 Every Discord mutation `PunishmentEngine` performs and every outbound Groq
 request go through a bounded-concurrency queue (`frame.actionQueue` /
 `frame.aiQueue`) instead of firing unbounded, so a burst can't trip a rate
-limit by hammering it all at once. `frame.getMetrics()` / `!gf metrics`
-gives you queue depth, cache stats, and average latency in one snapshot.
-Full write-up in `docs/PERFORMANCE.md`.
+limit by hammering it all at once. `!gf metrics` shows this server's numbers
+by default (open cases, flagged members, active layers), with a button on
+the message to switch to bot-wide totals across every server
+(`frame.getMetrics()` / `frame.getGuildMetrics(guildId)`). Full write-up in
+`docs/PERFORMANCE.md`.
 
 ## How punishment works
 
@@ -126,6 +133,8 @@ open case for that member from a moment ago. Full write-up in
 - `GETTING_STARTED.md` - adding GlassFrame to a bot you already have running.
 - `docs/PROTOCOL_LAYERS.md` - full architecture: containment vs. punishment,
   how a signal becomes an action, how to add a fifth layer.
+- `docs/STATE.md` - per-guild layer/whitelist state and how persistence
+  across restarts works.
 - `docs/CACHE_ARCHITECTURE.md` - every cache in the library, its key shape,
   its TTL, and how to turn on cache-level debug logging.
 - `docs/PERFORMANCE.md` - the bounded-concurrency queues and internal

package/dist/src/GlassFrame.js

@@ -23,13 +23,19 @@ const AntiNukeLayer = require("./layers/AntiNukeLayer");
 const AIModerationLayer = require("./layers/AIModerationLayer");
 
 const PrefixRouter = require("./commands/PrefixRouter");
-const { buildPanel } = require("./ui/ControlPanel");
+const { buildPanel, buildMetricsMessage } = require("./ui/ControlPanel");
+
+const LAYER_NAMES = ["basicSecurity", "antiRaid", "antiNuke", "aiModeration"];
 
 /**
  * GlassFrame Protocol - a layered, self-contained Discord security engine.
  * One instance manages every layer, the shared threat/punishment pipeline,
  * logging, the prefix command router, and the 5-button control panel for a
  * discord.js Client. See docs/PROTOCOL_LAYERS.md for the architecture.
+ *
+ * Everything is per-guild: which layers are active, and the whitelist, are
+ * tracked independently for every server the bot is in, and persisted
+ * through `stateStore` so they survive a restart. See docs/STATE.md.
  */
 class GlassFrame extends EventEmitter {
   constructor(client, options = {}) {
@@ -41,8 +47,13 @@ class GlassFrame extends EventEmitter {
 
     this.client = client;
     this.config = mergeConfig(defaultConfig, options.config || {});
-    this.whitelist = new Set(options.whitelist || []);
     this.stateStore = options.stateStore || new MemoryStateStore();
+    this.autoStart = options.autoStart || [];
+    // Seed list of user IDs treated as trusted in every guild the bot is
+    // in or joins - only applied the first time we see a guild (same rule
+    // as autoStart), never overriding a guild's own saved whitelist.
+    this.defaultWhitelist = new Set(options.whitelist || []);
+    this.whitelist = new Map(); // guildId -> Set<userId>
     this.panelMessages = new Map(); // messageId -> guildId
     this.debug = Boolean(options.debug ?? this.config.cache.debug);
 
@@ -71,14 +82,17 @@ class GlassFrame extends EventEmitter {
       debug: this.debug
     });
 
-    // All four layers start disabled - nothing runs until armed via
-    // options.autoStart, the control panel, or enableLayer().
+    // All four layers start disabled per guild - nothing runs until armed
+    // via options.autoStart, the control panel, or enableLayer(name, guildId).
     this.layers = {
       basicSecurity: new BasicSecurityLayer(this),
       antiRaid: new AntiRaidLayer(this),
       antiNuke: new AntiNukeLayer(this),
       aiModeration: new AIModerationLayer(this)
     };
+    // Event listeners attach exactly once, ever - per-guild on/off is a
+    // gate inside each handler, not an attach/detach cycle. See core/Layer.js.
+    for (const layer of Object.values(this.layers)) layer.attach();
 
     this.prefixRouter = new PrefixRouter(this);
     this.prefixRouter.attach();
@@ -86,9 +100,21 @@ class GlassFrame extends EventEmitter {
 
     if (this.debug) console.log(VersionInfo.banner());
 
-    for (const name of options.autoStart || []) {
-      if (this.layers[name]) this.layers[name].enable();
-    }
+    // Restore saved state (or apply autoStart/whitelist defaults) for every
+    // guild the bot is already in. This is async (stateStore.get() may be a
+    // real file/DB read), so `ready` lets callers that care about the exact
+    // moment restoration finishes await it explicitly - in practice a
+    // Discord message can't arrive faster than this resolves, so most code
+    // never needs to. Any guild the bot joins *after* this (guildCreate)
+    // restores independently and isn't part of `ready`.
+    const initialRestores = [...this.client.guilds.cache.values()].map((guild) =>
+      this._restoreGuildState(guild.id).catch((err) => this.emit("warning", { layer: "core", message: err.message }))
+    );
+    this.ready = Promise.all(initialRestores).then(() => undefined);
+
+    this.client.on("guildCreate", (guild) => {
+      this._restoreGuildState(guild.id).catch((err) => this.emit("warning", { layer: "core", message: err.message }));
+    });
   }
 
   isAuthorized(member) {
@@ -100,12 +126,28 @@ class GlassFrame extends EventEmitter {
   getStatus(guildId) {
     const out = {};
     for (const [name, layer] of Object.entries(this.layers)) {
-      out[name] = layer.enabled;
+      out[name] = layer.isEnabled(guildId);
     }
     return out;
   }
 
-  /** One-call health snapshot: event throughput/latency, queue depth, and every cache's stats. */
+  isWhitelisted(guildId, userId) {
+    return this.whitelist.get(guildId)?.has(userId) ?? false;
+  }
+
+  addToWhitelist(guildId, userId) {
+    if (!this.whitelist.has(guildId)) this.whitelist.set(guildId, new Set());
+    this.whitelist.get(guildId).add(userId);
+    this._persistGuildState(guildId);
+  }
+
+  removeFromWhitelist(guildId, userId) {
+    const existed = this.whitelist.get(guildId)?.delete(userId) ?? false;
+    if (existed) this._persistGuildState(guildId);
+    return existed;
+  }
+
+  /** One-call health snapshot: event throughput/latency, queue depth, and every cache's stats. Bot-wide, across every guild. */
   getMetrics() {
     return {
       performance: this.performance.snapshot(),
@@ -121,58 +163,125 @@ class GlassFrame extends EventEmitter {
     };
   }
 
-  enableLayer(name) {
+  /** Just this guild's numbers - which layers are on, and its slice of the shared threat/case caches. */
+  getGuildMetrics(guildId) {
+    const prefix = `${guildId}:`;
+    return {
+      status: this.getStatus(guildId),
+      whitelistSize: this.whitelist.get(guildId)?.size || 0,
+      flaggedMembers: this.threatEngine.scores.countByPrefix(prefix),
+      openCases: this.punishmentEngine.cases.countByPrefix(prefix)
+    };
+  }
+
+  enableLayer(name, guildId) {
     if (!this.layers[name]) throw new Error(`GlassFrame Protocol: unknown layer "${name}"`);
-    this.layers[name].enable();
+    if (!guildId) throw new Error("GlassFrame Protocol: enableLayer(name, guildId) requires a guildId - layers are per-guild.");
+    this.layers[name].enable(guildId);
     return this;
   }
 
-  disableLayer(name) {
+  disableLayer(name, guildId) {
     if (!this.layers[name]) throw new Error(`GlassFrame Protocol: unknown layer "${name}"`);
-    this.layers[name].disable();
+    if (!guildId) throw new Error("GlassFrame Protocol: disableLayer(name, guildId) requires a guildId - layers are per-guild.");
+    this.layers[name].disable(guildId);
     return this;
   }
 
+  /** Snapshots one guild's layer + whitelist state into stateStore. Fire-and-forget by design (never blocks a handler on disk/network I/O). */
+  _persistGuildState(guildId) {
+    const state = {
+      layers: this.getStatus(guildId),
+      whitelist: [...(this.whitelist.get(guildId) || [])]
+    };
+    Promise.resolve(this.stateStore.set(guildId, state)).catch((err) =>
+      this.emit("warning", { layer: "core", message: `failed to persist state for ${guildId}: ${err.message}` })
+    );
+  }
+
+  /** Loads a guild's saved state if one exists; otherwise applies the autoStart defaults (and persists that as the new baseline). */
+  async _restoreGuildState(guildId) {
+    const saved = await this.stateStore.get(guildId);
+
+    if (saved) {
+      for (const name of LAYER_NAMES) {
+        if (saved.layers?.[name]) this.layers[name].enable(guildId);
+      }
+      for (const userId of saved.whitelist || []) {
+        if (!this.whitelist.has(guildId)) this.whitelist.set(guildId, new Set());
+        this.whitelist.get(guildId).add(userId);
+      }
+      return;
+    }
+
+    for (const name of this.autoStart) {
+      if (this.layers[name]) this.layers[name].enable(guildId);
+    }
+    for (const userId of this.defaultWhitelist) {
+      this.addToWhitelist(guildId, userId);
+    }
+  }
+
   _attachButtonHandler() {
     this.client.on("interactionCreate", async (interaction) => {
-      if (!interaction.isButton() || !interaction.customId.startsWith("gfp_toggle_")) return;
+      if (!interaction.isButton()) return;
 
       try {
-        if (!this.isAuthorized(interaction.member)) {
-          await interaction.reply({ content: "You need Manage Server permission to use this.", ephemeral: true });
-          return;
+        if (interaction.customId.startsWith("gfp_toggle_")) {
+          await this._handlePanelButton(interaction);
+        } else if (interaction.customId.startsWith("gfp_metrics_")) {
+          await this._handleMetricsButton(interaction);
         }
+      } catch (err) {
+        this.emit("warning", { layer: "controlPanel", message: err.message });
+      }
+    });
+  }
 
-        const layerKey = interaction.customId.replace("gfp_toggle_", "");
-
-        if (layerKey === "all") {
-          const status = this.getStatus(interaction.guild.id);
-          const allOn = Object.keys(this.layers).every((l) => status[l]);
-          for (const name of Object.keys(this.layers)) {
-            if (allOn) this.disableLayer(name);
-            else this.enableLayer(name);
-          }
-        } else if (this.layers[layerKey]) {
-          if (this.layers[layerKey].enabled) this.disableLayer(layerKey);
-          else this.enableLayer(layerKey);
-        } else {
-          return;
-        }
+  async _handlePanelButton(interaction) {
+    if (!this.isAuthorized(interaction.member)) {
+      await interaction.reply({ content: "You need Manage Server permission to use this.", ephemeral: true });
+      return;
+    }
 
-        const payload = buildPanel(this, interaction.guild.id);
-        await interaction.update(payload);
+    const guildId = interaction.guild.id;
+    const layerKey = interaction.customId.replace("gfp_toggle_", "");
 
-        await this.logger.log(interaction.guild, {
-          level: "info",
-          title: "Protocol Layer Toggled",
-          description: `${interaction.user.tag} updated GlassFrame Protocol layers from the control panel.`,
-          dedupeKey: "panel:toggle"
-        });
-      } catch (err) {
-        this.emit("warning", { layer: "controlPanel", message: err.message });
+    if (layerKey === "all") {
+      const status = this.getStatus(guildId);
+      const allOn = Object.keys(this.layers).every((l) => status[l]);
+      for (const name of Object.keys(this.layers)) {
+        if (allOn) this.disableLayer(name, guildId);
+        else this.enableLayer(name, guildId);
       }
+    } else if (this.layers[layerKey]) {
+      if (this.layers[layerKey].isEnabled(guildId)) this.disableLayer(layerKey, guildId);
+      else this.enableLayer(layerKey, guildId);
+    } else {
+      return;
+    }
+
+    const payload = buildPanel(this, guildId);
+    await interaction.update(payload);
+
+    await this.logger.log(interaction.guild, {
+      level: "info",
+      title: "Protocol Layer Toggled",
+      description: `${interaction.user.tag} updated GlassFrame Protocol layers from the control panel.`,
+      dedupeKey: "panel:toggle"
     });
   }
+
+  async _handleMetricsButton(interaction) {
+    if (!this.isAuthorized(interaction.member)) {
+      await interaction.reply({ content: "You need Manage Server permission to use this.", ephemeral: true });
+      return;
+    }
+
+    const scope = interaction.customId.replace("gfp_metrics_", ""); // "guild" or "global"
+    const payload = buildMetricsMessage(this, interaction.guild.id, scope);
+    await interaction.update(payload);
+  }
 }
 
 function mergeConfig(base, override) {

package/dist/src/commands/PrefixRouter.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const { buildPanel } = require("../ui/ControlPanel");
+const { buildPanel, buildMetricsMessage } = require("../ui/ControlPanel");
 const { buildLogMessage } = require("../logging/ComponentsV2");
 
 const LAYER_NAMES = ["antiRaid", "antiNuke", "basicSecurity", "aiModeration"];
@@ -79,9 +79,9 @@ class PrefixRouter {
         `${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 - show performance and cache health`,
+        `${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 all punitive action`,
+        `${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")
@@ -97,8 +97,8 @@ class PrefixRouter {
     }
 
     const action = sub.toLowerCase();
-    if (action === "add") this.frame.whitelist.add(id);
-    else if (action === "remove") this.frame.whitelist.delete(id);
+    if (action === "add") this.frame.addToWhitelist(message.guild.id, id);
+    else if (action === "remove") this.frame.removeFromWhitelist(message.guild.id, id);
     else return;
 
     await message.reply({
@@ -121,26 +121,7 @@ class PrefixRouter {
   }
 
   async _metrics(message) {
-    const m = this.frame.getMetrics();
-    const fmtCache = (c) => `size ${c.size} | hits ${c.hits} | misses ${c.misses} | evictions ${c.evictions}`;
-    const fmtQueue = (q) => `active ${q.active}/${q.concurrency} | pending ${q.pending} | completed ${q.completed} | failed ${q.failed}`;
-    const fmtLatency = Object.entries(m.performance.avgLatencyMs)
-      .map(([name, ms]) => `${name}: ${ms}ms avg`)
-      .join("\n") || "no samples yet";
-
-    const payload = buildLogMessage({
-      level: "info",
-      title: "GlassFrame Protocol - Performance",
-      description: `Uptime: ${Math.round(m.performance.uptimeMs / 60000)} min`,
-      fields: [
-        { name: "Action queue", value: fmtQueue(m.queues.actions) },
-        { name: "AI queue", value: fmtQueue(m.queues.ai) },
-        { name: "Threat score cache", value: fmtCache(m.caches.threatScores) },
-        { name: "Open case cache", value: fmtCache(m.caches.openCases) },
-        { name: "Groq verdict cache", value: fmtCache(m.caches.groqVerdicts) },
-        { name: "Average latency", value: fmtLatency }
-      ]
-    });
+    const payload = buildMetricsMessage(this.frame, message.guild.id, "guild");
     await message.channel.send(payload);
   }
 

package/dist/src/core/Cache.js

@@ -84,6 +84,16 @@ class ProtocolCache {
     return { ...this.stats, size: this.store.size, name: this.name };
   }
 
+  /** Counts non-expired entries whose key starts with `prefix` - used for per-guild breakdowns of a `guildId:userId`-keyed cache. */
+  countByPrefix(prefix) {
+    const now = Date.now();
+    let count = 0;
+    for (const [key, entry] of this.store) {
+      if (key.startsWith(prefix) && now <= entry.expiresAt) count++;
+    }
+    return count;
+  }
+
   destroy() {
     if (this._sweeper) clearInterval(this._sweeper);
   }

package/dist/src/core/Layer.js

@@ -13,18 +13,20 @@ const EventEmitter = require("events");
  * verification level, revert a role's permissions) since those are
  * time-critical and aren't about penalizing one member.
  *
- * enable()/disable() are the only lifecycle a layer needs to implement -
- * disable() fully detaches every listener the layer attached, so a disabled
- * layer does zero work rather than quietly early-returning inside a handler
- * that's still subscribed.
+ * Enabled state is per-guild, not global: one bot process can serve many
+ * guilds, each with its own independent set of active layers. Discord's
+ * gateway doesn't support attaching a listener scoped to a single guild, so
+ * the underlying event listener is attached exactly once, ever
+ * (attach()), and every handler must gate its actual work behind
+ * `this.isEnabled(guildId)` as its first check - a disabled guild does zero
+ * work past that check, an enabled one proceeds normally.
  */
 class Layer extends EventEmitter {
   constructor(name, frame) {
     super();
     this.name = name;
     this.frame = frame;
-    this.enabled = false;
-    this._listeners = [];
+    this.enabledGuilds = new Set();
   }
 
   get client() {
@@ -35,34 +37,37 @@ class Layer extends EventEmitter {
     return this.frame.config[this.name] || {};
   }
 
+  isEnabled(guildId) {
+    return this.enabledGuilds.has(guildId);
+  }
+
   _listen(emitter, event, handler) {
     emitter.on(event, handler);
-    this._listeners.push([emitter, event, handler]);
   }
 
-  enable() {
-    if (this.enabled) return this;
-    this.enabled = true;
-    this.onEnable();
-    this.frame.emit("layerToggled", { layer: this.name, enabled: true });
+  enable(guildId) {
+    const already = this.enabledGuilds.has(guildId);
+    this.enabledGuilds.add(guildId);
+    if (!already) {
+      this.frame._persistGuildState(guildId);
+      this.frame.emit("layerToggled", { layer: this.name, guildId, enabled: true });
+    }
     return this;
   }
 
-  disable() {
-    if (!this.enabled) return this;
-    this.enabled = false;
-    for (const [emitter, event, handler] of this._listeners) {
-      emitter.removeListener(event, handler);
+  disable(guildId) {
+    const had = this.enabledGuilds.delete(guildId);
+    if (had) {
+      this.frame._persistGuildState(guildId);
+      this.frame.emit("layerToggled", { layer: this.name, guildId, enabled: false });
     }
-    this._listeners = [];
-    this.onDisable();
-    this.frame.emit("layerToggled", { layer: this.name, enabled: false });
     return this;
   }
 
-  // Subclasses override these two hooks.
-  onEnable() {}
-  onDisable() {}
+  // Subclasses override this: attach event listeners exactly once here
+  // (called once per layer, at GlassFrame construction). Gate all real work
+  // behind `this.isEnabled(guildId)`.
+  attach() {}
 }
 
 module.exports = Layer;

package/dist/src/core/VersionInfo.js

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

package/dist/src/layers/AIModerationLayer.js

@@ -29,20 +29,19 @@ class AIModerationLayer extends Layer {
     return this.frame.groqClient;
   }
 
-  onEnable() {
+  attach() {
     if (!this.groq?.available) {
       this.frame.emit("warning", {
         layer: "aiModeration",
-        message: "No Groq API keys configured - layer is active but will stay idle. Set aiModeration.apiKeys in config."
+        message: "No Groq API keys configured - layer can be armed but will stay idle. Set aiModeration.apiKeys in config."
       });
     }
     this._listen(this.client, "messageCreate", (message) => this._handle(message).catch(() => {}));
   }
 
-  onDisable() {}
-
   async _handle(message) {
     if (!message.guild || message.author.bot || !message.content) return;
+    if (!this.isEnabled(message.guild.id)) return;
     if (!this.groq?.available) return;
 
     const cfg = this.config;

package/dist/src/layers/AntiNukeLayer.js

@@ -33,22 +33,24 @@ class AntiNukeLayer extends Layer {
     this.webhookMessageCounts = new Map(); // webhookId -> timestamps[]
   }
 
-  onEnable() {
+  attach() {
     this._listen(this.client, "guildAuditLogEntryCreate", (entry, guild) =>
       this._handleEntry(entry, guild).catch(() => {})
     );
     if (this.config.webhookAbuse.enabled) {
       this._listen(this.client, "messageCreate", (message) => this._handleWebhookMessage(message).catch(() => {}));
     }
-    // Give every guild an immediate role audit the moment AntiNuke is armed.
-    for (const guild of this.client.guilds.cache.values()) {
-      this._auditRoles(guild).catch(() => {});
-    }
   }
 
-  onDisable() {
-    this.actionLog.clear();
-    this.webhookMessageCounts.clear();
+  /** Give a guild an immediate role audit the moment AntiNuke is armed for it. */
+  enable(guildId) {
+    const wasEnabled = this.isEnabled(guildId);
+    super.enable(guildId);
+    if (!wasEnabled) {
+      const guild = this.client.guilds.cache.get(guildId);
+      if (guild) this._auditRoles(guild).catch(() => {});
+    }
+    return this;
   }
 
   _record(guildId, executorId, type) {
@@ -66,12 +68,13 @@ class AntiNukeLayer extends Layer {
   async _handleEntry(entry, guild) {
     const type = EVENT_MAP[entry.action];
     if (!type) return;
+    if (!this.isEnabled(guild.id)) return;
     this.frame.performance.recordEvent(`antiNuke.auditEntry.${type}`);
 
     const executor = entry.executor;
     if (!executor || executor.id === this.client.user.id) return;
     if (executor.id === guild.ownerId) return;
-    if (this.frame.whitelist.has(executor.id)) return;
+    if (this.frame.isWhitelisted(guild.id, executor.id)) return;
 
     if (type === "roleUpdate" && this.config.watchDangerousGrants) {
       await this._checkDangerousGrant(entry, guild, executor);
@@ -206,6 +209,7 @@ class AntiNukeLayer extends Layer {
    */
   async _handleWebhookMessage(message) {
     if (!message.webhookId || !message.guild) return;
+    if (!this.isEnabled(message.guild.id)) return;
     const info = this.recentWebhooks.get(message.webhookId);
     if (!info) return;
 

package/dist/src/layers/AntiRaidLayer.js

@@ -12,15 +12,10 @@ class AntiRaidLayer extends Layer {
     this.joinProfiles = new Map(); // guildId -> [{ at, created }] for cluster correlation
   }
 
-  onEnable() {
+  attach() {
     this._listen(this.client, "guildMemberAdd", (member) => this._handleJoin(member).catch(() => {}));
   }
 
-  onDisable() {
-    this.joinTimestamps.clear();
-    this.joinProfiles.clear();
-  }
-
   isLockedDown(guildId) {
     const until = this.lockedDown.get(guildId);
     return typeof until === "number" && Date.now() < until;
@@ -75,6 +70,7 @@ class AntiRaidLayer extends Layer {
 
   async _handleJoin(member) {
     const { guild, user } = member;
+    if (!this.isEnabled(guild.id)) return;
     this.frame.performance.recordEvent("antiRaid.guildMemberAdd");
     const joinCount = this._recordJoin(guild.id);
     const { score: altScore, entropyCheck } = this._altScore(user);

package/dist/src/layers/BasicSecurityLayer.js

@@ -6,31 +6,29 @@ const { classifyMessage } = require("../utils/nlpEngine");
 class BasicSecurityLayer extends Layer {
   constructor(frame) {
     super("basicSecurity", frame);
-    this.buffers = new Map(); // userId -> { timestamps, lastContent, dupCount }
+    this.buffers = new Map(); // `guildId:userId` -> { timestamps, lastContent, dupCount }
   }
 
-  onEnable() {
+  attach() {
     this._listen(this.client, "messageCreate", (message) => this._handle(message).catch(() => {}));
   }
 
-  onDisable() {
-    this.buffers.clear();
-  }
-
-  _bufferFor(userId) {
-    if (!this.buffers.has(userId)) {
-      this.buffers.set(userId, { timestamps: [], lastContent: "", dupCount: 0 });
+  _bufferFor(guildId, userId) {
+    const key = `${guildId}:${userId}`;
+    if (!this.buffers.has(key)) {
+      this.buffers.set(key, { timestamps: [], lastContent: "", dupCount: 0 });
     }
-    return this.buffers.get(userId);
+    return this.buffers.get(key);
   }
 
   async _handle(message) {
     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");
 
     const cfg = this.config;
-    const buf = this._bufferFor(message.author.id);
+    const buf = this._bufferFor(message.guild.id, message.author.id);
     const now = Date.now();
 
     buf.timestamps = buf.timestamps.filter((t) => now - t < cfg.spam.windowMs);

package/dist/src/moderation/PunishmentEngine.js

@@ -30,9 +30,10 @@ class PunishmentEngine extends EventEmitter {
     // limits. Falls back to running inline if no queue is supplied.
     this.queue = queue || { push: (task) => task() };
     this.performance = performance || { recordEvent() {}, time: () => () => {} };
-    // Accept the same Set the rest of GlassFrame uses (not a copy), so
-    // runtime whitelist edits (e.g. !gf whitelist add) apply immediately here too.
-    this.whitelist = whitelist instanceof Set ? whitelist : new Set(whitelist || []);
+    // Accept the same Map the rest of GlassFrame uses (guildId -> Set<userId>),
+    // by reference, not a copy, so runtime edits (e.g. !gf whitelist add)
+    // apply immediately here too.
+    this.whitelist = whitelist;
     this.cases = new ProtocolCache("open-cases", { ttlMs: this.config.caseCooldownMs, debug });
   }
 
@@ -47,7 +48,7 @@ class PunishmentEngine extends EventEmitter {
   async report({ guild, member, layer, weight, reason }) {
     if (!member) return null;
     const userId = member.id;
-    if (this.whitelist.has(userId)) return null;
+    if (this.whitelist.get(guild.id)?.has(userId)) return null;
 
     const { score, tier } = this.threatEngine.addSignal(guild.id, userId, { layer, weight, reason });
     if (tier === "none") return null;

package/dist/src/ui/ControlPanel.js

@@ -55,4 +55,68 @@ function buildPanel(frame, guildId) {
   return { flags: MessageFlags.IsComponentsV2, components: [container] };
 }
 
-module.exports = { buildPanel, BUTTONS };
+/**
+ * !gf metrics shows THIS SERVER's numbers by default - the one button on
+ * this message switches to bot-wide (all servers) and back. This is a
+ * second, separate button from the 5-button panel above; it lives on the
+ * metrics command's own message, not on the panel.
+ */
+function buildMetricsMessage(frame, guildId, scope = "guild") {
+  const isGlobal = scope === "global";
+  const fields = [];
+
+  if (isGlobal) {
+    const m = frame.getMetrics();
+    const fmtCache = (c) => `size ${c.size} | hits ${c.hits} | misses ${c.misses} | evictions ${c.evictions}`;
+    const fmtQueue = (q) => `active ${q.active}/${q.concurrency} | pending ${q.pending} | completed ${q.completed} | failed ${q.failed}`;
+    const fmtLatency =
+      Object.entries(m.performance.avgLatencyMs)
+        .map(([name, ms]) => `${name}: ${ms}ms avg`)
+        .join("\n") || "no samples yet";
+
+    fields.push(
+      { name: "Uptime", value: `${Math.round(m.performance.uptimeMs / 60000)} min` },
+      { name: "Action queue", value: fmtQueue(m.queues.actions) },
+      { name: "AI queue", value: fmtQueue(m.queues.ai) },
+      { name: "Threat score cache (all servers)", value: fmtCache(m.caches.threatScores) },
+      { name: "Open case cache (all servers)", value: fmtCache(m.caches.openCases) },
+      { name: "Groq verdict cache (all servers)", value: fmtCache(m.caches.groqVerdicts) },
+      { name: "Average latency", value: fmtLatency }
+    );
+  } else {
+    const gm = frame.getGuildMetrics(guildId);
+    const statusLines = REAL_LAYERS.map((l) => `${gm.status[l] ? "ACTIVE" : "inactive"} - ${l}`).join("\n");
+
+    fields.push(
+      { name: "Layers", value: statusLines },
+      { name: "Flagged members right now", value: String(gm.flaggedMembers) },
+      { name: "Open cases", value: String(gm.openCases) },
+      { name: "Whitelisted users", value: String(gm.whitelistSize) }
+    );
+  }
+
+  const nextScope = isGlobal ? "guild" : "global";
+  const toggleButton = new ButtonBuilder()
+    .setCustomId(`gfp_metrics_${nextScope}`)
+    .setLabel(isGlobal ? "Show This Server" : "Show Global (All Servers)")
+    .setStyle(ButtonStyle.Secondary);
+  const row = new ActionRowBuilder().addComponents(toggleButton);
+
+  const container = new ContainerBuilder().setAccentColor(0x5865f2);
+  container.addTextDisplayComponents(
+    new TextDisplayBuilder().setContent(
+      isGlobal ? "**GlassFrame Protocol - Global Metrics**" : "**GlassFrame Protocol - This Server's Metrics**"
+    )
+  );
+  container.addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Small));
+  container.addTextDisplayComponents(
+    new TextDisplayBuilder().setContent(fields.map((f) => `**${f.name}**\n${f.value}`).join("\n\n"))
+  );
+  container.addSeparatorComponents(new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Small));
+  container.addActionRowComponents(row);
+  container.addTextDisplayComponents(new TextDisplayBuilder().setContent("-# GlassFrame Protocol"));
+
+  return { flags: MessageFlags.IsComponentsV2, components: [container] };
+}
+
+module.exports = { buildPanel, buildMetricsMessage, BUTTONS };

package/docs/CACHE_ARCHITECTURE.md

@@ -15,6 +15,10 @@ watch it operate at runtime - see "Turning on cache logging" below.
 - `getStats()` returns hits/misses/sets/evictions/size for any cache at
   runtime, which is useful when you're tuning thresholds in `config.js` and
   want to know whether a value is actually being reused.
+- `countByPrefix(prefix)` counts non-expired entries whose key starts with
+  a prefix - this is how `frame.getGuildMetrics(guildId)` gets one server's
+  slice of the `threat-scores` and `open-cases` caches below without
+  needing a separate per-guild cache for each.
 
 ## Caches in use
 

package/docs/COMMANDS.md

@@ -9,30 +9,44 @@ running twice or getting a "slow down" reply of its own.
 
 | Command | Does |
 |---|---|
-| `!gf panel` | Sends the 5-button control panel (see below). |
-| `!gf status` | Shows which of the four layers are currently active. |
+| `!gf panel` | Sends the 5-button control panel for this server (see below). |
+| `!gf status` | Shows which of the four layers are currently active **in this server**. |
 | `!gf scan` | Runs `RoleAnalyzer.scanRoles()` on demand and reports any role name/permission mismatches. |
-| `!gf metrics` | Shows queue depth, cache stats, and average latency - see `docs/PERFORMANCE.md`. |
+| `!gf metrics` | Shows **this server's** metrics by default - a button on the message switches to bot-wide (all servers) and back. See `docs/PERFORMANCE.md`. |
 | `!gf phishing add <domain>` | Adds a domain to the link blocklist. |
 | `!gf phishing remove <domain>` | Removes a domain from the blocklist. |
 | `!gf phishing list` | Lists every blocked domain. |
-| `!gf whitelist add <userId>` | Exempts a user from all punitive action. |
-| `!gf whitelist remove <userId>` | Removes an exemption. |
+| `!gf whitelist add <userId>` | Exempts a user from punitive action **in this server**. |
+| `!gf whitelist remove <userId>` | Removes that exemption for this server. |
 | `!gf help` | Lists these commands. |
 
+Everything above operates on the server the command was sent in - arming
+AntiRaid, whitelisting someone, or checking status in one server has no
+effect on any other server the bot is in. See `docs/STATE.md`.
+
 ## The control panel
 
-`!gf panel` sends a message with exactly five buttons in one row:
+`!gf panel` sends a message with exactly five buttons in one row, scoped to
+the server it was sent in:
 
 1. **Activate/Deactivate AntiRaid**
 2. **Activate/Deactivate AI Moderation**
 3. **Activate/Deactivate AntiNuke**
 4. **Activate/Deactivate Basic Security**
-5. **Activate/Deactivate Full Protocol** - arms or disarms all four at once
+5. **Activate/Deactivate Full Protocol** - arms or disarms all four at once, for this server only
 
-Every layer starts disabled - nothing runs until it's explicitly activated,
-either from the panel or via `frame.enableLayer("antiRaid")` in code. Button
-labels flip between Activate/Deactivate based on current state, and the
+Every layer starts disabled in every server - nothing runs until it's
+explicitly activated, either from the panel or via
+`frame.enableLayer("antiRaid", guildId)` in code. Button labels flip
+between Activate/Deactivate based on that server's current state, and the
 panel message updates in place on every click rather than posting a new
 message each time. Clicking a button also drops one aggregated log line in
 the security log channel noting who changed what.
+
+## The metrics button
+
+`!gf metrics` (and the panel's numbers, indirectly) has one button of its
+own, separate from the panel's five: **Show Global (All Servers)** /
+**Show This Server**, flipping the message between this server's counts
+(open cases, flagged members, active layers, whitelist size) and bot-wide
+totals across every server (queue depth, cache stats, average latency).

package/docs/PROTOCOL_LAYERS.md

@@ -37,11 +37,14 @@ instead of twenty separate ones.
 | `antiNuke` | `guildAuditLogEntryCreate`, plus `messageCreate` only when webhook-abuse watching is on | reverts a dangerous permission grant, deletes an abusive webhook | destructive-action bursts per executor across channels/roles/bans/kicks/webhooks/emoji/stickers |
 | `aiModeration` | `messageCreate` (independently of `basicSecurity`) | - | AI-confirmed category + confidence for gray-zone messages |
 
-Each layer extends `src/core/Layer.js`, which handles enabling/disabling
-cleanly: `enable()` attaches the layer's listeners, `disable()` detaches
-every one of them (not just an early-return check inside the handler), so a
-disabled layer truly does no work rather than quietly skipping its own
-logic on every event.
+Each layer extends `src/core/Layer.js`. Its event listeners attach exactly
+once, ever (`attach()`), rather than on every enable/disable - Discord's
+gateway has no concept of a listener scoped to one guild, so the listener
+always fires and each handler's first real check is
+`if (!this.isEnabled(guildId)) return;`. Enabling or disabling a layer is
+per-guild: `layer.enable(guildId)` / `layer.disable(guildId)` track a
+`Set<guildId>` (`enabledGuilds`), not a single boolean - see
+`docs/STATE.md` for the full per-guild state and persistence model.
 
 `basicSecurity` and `aiModeration` both listen to `messageCreate`
 independently rather than one calling into the other - either can be
@@ -75,15 +78,18 @@ how they respond.
 ## Why AntiNuke also runs a role audit
 
 `RoleAnalyzer.scanRoles()` (role name vs. permission mismatch detection)
-runs automatically once, the moment AntiNuke is armed, and again on demand
-via `!gf scan`. It reports flags, never actions - a human decides what, if
-anything, to do about a role that looks like impersonation bait or quietly
-holds dangerous permissions.
+runs automatically once for a server the moment AntiNuke is armed *for
+that server*, and again on demand via `!gf scan`. It reports flags, never
+actions - a human decides what, if anything, to do about a role that looks
+like impersonation bait or quietly holds dangerous permissions.
 
 ## Adding a fifth layer
 
-Extend `Layer`, implement `onEnable()` / `onDisable()`, report signals via
+Extend `Layer`, implement `attach()` (register your event listener(s) once;
+gate all real work behind `this.isEnabled(guildId)`), report signals via
 `this.frame.punishmentEngine.report({ guild, member, layer, weight, reason })`,
 register the instance in `GlassFrame`'s `this.layers` map, and add a button
 in `src/ui/ControlPanel.js` if you want it on the panel. Nothing else in the
-pipeline needs to know the new layer exists.
+pipeline needs to know the new layer exists - per-guild enable/disable,
+state persistence, and metrics all come from the base `Layer` class for
+free.

package/docs/STATE.md

@@ -0,0 +1,101 @@
+# Per-Guild State and Persistence
+
+One GlassFrame instance can serve many Discord servers at once. Two things
+are tracked independently per server, and both survive a bot restart if you
+give GlassFrame a persistent `stateStore`:
+
+- **Which layers are on.** Server A can run AntiRaid + AntiNuke while Server
+  B runs nothing, or everything, independently. There is no such thing as
+  "GlassFrame is on" globally - only "layer X is on for guild Y."
+- **The whitelist.** Exempting a user in one server does not exempt them
+  anywhere else.
+
+Everything else that's naturally guild-scoped already was before this -
+threat scores, open cases, join-rate tracking, audit-log burst tracking are
+all keyed by `guildId` internally. The two items above are the ones that
+used to be accidentally global; see `CHANGELOG.md` for the 2.0.0 entry if
+you're upgrading from an earlier version.
+
+## How it's stored
+
+`Layer.enabledGuilds` is a `Set<guildId>` per layer (not one shared
+boolean). `GlassFrame.whitelist` is a `Map<guildId, Set<userId>>`. Both are
+read through the frame's own methods rather than touched directly:
+
+```js
+frame.enableLayer("antiRaid", guildId);
+frame.disableLayer("antiRaid", guildId);
+frame.getStatus(guildId); // { basicSecurity: true, antiRaid: false, ... }
+
+frame.addToWhitelist(guildId, userId);
+frame.removeFromWhitelist(guildId, userId);
+frame.isWhitelisted(guildId, userId);
+```
+
+## Persistence across restarts
+
+Pass a `stateStore` when constructing GlassFrame - `MemoryStateStore`
+(default, lost on restart) or `JSONFileStateStore` (a single JSON file, no
+database, ARM64/Termux-friendly):
+
+```js
+const { JSONFileStateStore } = require("glassframe-protocol");
+
+const frame = new GlassFrame(client, {
+  getLogChannel: /* ... */,
+  stateStore: new JSONFileStateStore("./glassframe-state.json"),
+  autoStart: ["basicSecurity", "antiRaid"]
+});
+```
+
+Every time a layer is toggled or the whitelist changes for a guild,
+GlassFrame writes that guild's full state (which layers are on, its
+whitelist) to the store. At startup, for every guild the bot is already in,
+and again automatically whenever the bot joins a new guild
+(`guildCreate`), GlassFrame:
+
+1. Checks the store for saved state for that guild.
+2. If found, restores exactly that - the layers that were on stay on.
+3. If nothing is saved yet (a guild GlassFrame has never seen before),
+   applies `autoStart` and the constructor's `whitelist` option (see below)
+   as that guild's starting defaults.
+
+Restoring is async (a real `stateStore` might read from disk or a
+database), so it can't finish before the constructor returns. In practice
+this resolves well before a Discord event could possibly arrive, so most
+code never needs to think about it - but if you want a guarantee, `await
+frame.ready` after construction; it resolves once every guild the bot was
+already in has been restored (guilds joined later via `guildCreate`
+restore independently and aren't part of this promise, since there's
+nothing they could race against).
+
+`autoStart` and the `whitelist` option are only ever *defaults for a
+guild's first run* - once a guild has any saved state (even "everything
+off"), neither applies to it again; the saved state is the source of truth
+from then on.
+
+## The `whitelist` constructor option
+
+```js
+new GlassFrame(client, { getLogChannel: /* ... */, whitelist: ["123456789012345678"] });
+```
+
+This seeds a starting whitelist for every guild - both the ones already in
+`client.guilds.cache` and any the bot joins later - the first time
+GlassFrame sees that guild (i.e., it never overrides a guild's own saved
+whitelist). Think of it as "these users are trusted everywhere by default";
+`frame.removeFromWhitelist(guildId, userId)` still works normally
+per-guild afterward.
+
+## Writing your own store
+
+Implement two async methods and pass an instance as `stateStore`:
+
+```js
+class MyStore {
+  async get(guildId) { /* return the saved state object, or null */ }
+  async set(guildId, state) { /* persist `state` for this guildId */ }
+}
+```
+
+`state` is `{ layers: { basicSecurity: true, antiRaid: false, ... }, whitelist: ["userId1", "userId2"] }`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glassframe-protocol",
-  "version": "1.2.1",
+  "version": "2.0.0",
   "description": "A layered, self-contained Discord security engine - AntiRaid, AntiNuke, Basic Security, and optional Groq-powered AI Moderation sharing one threat-scoring and punishment pipeline. Prefix commands only, Components V2 output, no slash commands.",
   "main": "dist/index.js",
   "files": [