glassframe-protocol 2.1.0 → 2.2.0

package/CHANGELOG.md

@@ -14,6 +14,50 @@ lives in `src/core/VersionInfo.js` (`VersionInfo.info()` /
 `VersionInfo.banner()`), so code can read the current version without
 parsing this file.
 
+## [2.2.0] - 2026-08-05
+
+Fixes a real bug in message deletion and adds tenure-aware leniency for
+spam detection. No breaking changes.
+
+### Fixed
+
+- **Protected/trusted members' messages were being deleted anyway.**
+  `BasicSecurityLayer` computed trust and used it to gate the @everyone
+  check, but every *other* trigger (message rate, duplicate flood, mention
+  spam, scam/phishing/raid language, links) deleted the message
+  unconditionally, before `PunishmentEngine` ever got a chance to decide
+  the sender shouldn't be punished. A real admin posting several messages
+  quickly during a busy conversation, or pasting a couple of links, had
+  their message removed even though they were never going to be actioned.
+  Deletion is now gated the same way punishment is: never for a HIGH/
+  PROTECTED-trust sender.
+
+### Added
+
+- **Expanded `roleAnalysis.protectedNames`**: added `co-owner`, `founder`,
+  `management`, `manager`, `support`, `helper`, `developer` alongside the
+  existing `owner`/`admin`/`administrator`/`moderator`/`mod`/`staff`/
+  `discord staff`/`security`.
+- **Established-member leniency** (`RoleAnalyzer.isEstablishedMember()`,
+  `roleAnalysis.maturity`, `basicSecurity.establishedMemberLeniency`) - a
+  member with an old-enough account (default 6 months) and long-enough
+  tenure in the server (default 1 month) needs a much bigger burst before
+  a pure rate/duplicate-flood signal fires at all (2.5x by default), that
+  signal counts for less when it does (0.3x weight by default), and their
+  messages are never deleted for tripping *only* a rate/volume signal.
+  This is a separate axis from role-based trust above - an ordinary member
+  with no special role can be "established."
+
+  Deliberately scoped narrow: this only ever softens detection of *sending
+  frequently*. Scam/phishing/raid-recruitment language, suspicious links,
+  and non-trusted mass pings stay at full sensitivity and still get
+  deleted and actioned regardless of how long the account has existed -
+  tenure says nothing about whether a specific message is dangerous, and a
+  long-standing account can still genuinely raid, spam, or get
+  compromised. Modeled on how invisible CAPTCHA works: judge from signals
+  already available rather than one blunt threshold, without ever handing
+  out blanket immunity.
+
 ## [2.1.0] - 2026-08-01
 
 Additive - nothing from 2.0.0's API changes. New detections, a plugin

package/dist/config.js

@@ -11,8 +11,9 @@ module.exports = {
   roleAnalysis: {
     // Role-name fragments (lowercased, substring match) that imply real authority.
     protectedNames: [
-      "owner", "admin", "administrator", "moderator", "mod",
-      "staff", "discord staff", "security"
+      "owner", "co-owner", "founder", "admin", "administrator",
+      "moderator", "mod", "staff", "discord staff", "security",
+      "management", "manager", "support", "helper", "developer"
     ],
     // Permission names (PermissionsBitField.Flags keys) treated as "dangerous"
     // when granted to a role - watched by AntiNuke's grant watchdog.
@@ -23,7 +24,16 @@ module.exports = {
     // Permission names that mark a member as genuinely trusted staff.
     trustPermissions: ["Administrator", "ManageGuild", "ManageRoles", "BanMembers", "KickMembers"],
     // A role younger than this that already holds a dangerous permission is extra suspicious.
-    newRoleGraceMs: 1000 * 60 * 10
+    newRoleGraceMs: 1000 * 60 * 10,
+    // A DIFFERENT axis from role-based trust above: how long an account
+    // and membership has simply existed, with no relation to roles or
+    // permissions. Used only to soften pure rate/volume spam detection for
+    // members who are just very active - see basicSecurity.establishedMemberLeniency
+    // and docs/PROTOCOL_LAYERS.md ("Established-member leniency").
+    maturity: {
+      minAccountAgeMs: 1000 * 60 * 60 * 24 * 180, // 6 months
+      minServerTenureMs: 1000 * 60 * 60 * 24 * 30 // 1 month in this server
+    }
   },
 
   threatEngine: {
@@ -48,7 +58,18 @@ module.exports = {
     // Seed domains for PhishingDatabase (src/security/PhishingDatabase.js).
     // Empty by default - populate with what you actually see via
     // `!gf phishing add <domain>` rather than shipping unverified blocklists.
-    linkGuard: { seedDomains: [] }
+    linkGuard: { seedDomains: [] },
+    // See roleAnalysis.maturity. Applies ONLY to pure rate/volume signals
+    // (message rate, duplicate flood) for established members - content
+    // signals (scam/phishing/raid language, links, non-trusted mass pings)
+    // stay at full strength no matter how old or long-tenured the sender
+    // is, since tenure says nothing about whether a given message is
+    // dangerous. Set both multipliers to 1 to disable this and treat
+    // every member identically.
+    establishedMemberLeniency: {
+      thresholdMultiplier: 2.5, // established members need this many times the normal rate before a signal fires at all
+      weightMultiplier: 0.3 // and the signal counts for less when it does
+    }
   },
 
   antiRaid: {

package/dist/src/core/VersionInfo.js

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

package/dist/src/layers/BasicSecurityLayer.js

@@ -45,21 +45,35 @@ class BasicSecurityLayer extends Layer {
     const linkFlag = this._checkLinks(message.content || "");
     const hasInvite = this._checkInviteLink(message.content || "");
     const trust = this.frame.roleAnalyzer.trustLevel(message.member);
+    const established = this.frame.roleAnalyzer.isEstablishedMember(message.member);
+    const leniency = cfg.establishedMemberLeniency;
 
     const reasons = [];
     let weight = 0;
-
-    if (buf.timestamps.length >= cfg.spam.messageThreshold) {
-      reasons.push(`message rate ${buf.timestamps.length}/${cfg.spam.windowMs / 1000}s`);
-      weight += 20;
+    let contentSignalFired = false; // anything other than pure rate/volume - see the deletion gate below
+
+    // Rate/volume signals: an established member needs a much bigger burst
+    // before this counts as a signal at all, and it counts for less when it
+    // does - see roleAnalysis.maturity for the reasoning. A brand-new or
+    // short-tenured member gets the normal, stricter threshold.
+    const messageThreshold = established ? Math.ceil(cfg.spam.messageThreshold * leniency.thresholdMultiplier) : cfg.spam.messageThreshold;
+    if (buf.timestamps.length >= messageThreshold) {
+      reasons.push(`message rate ${buf.timestamps.length}/${cfg.spam.windowMs / 1000}s${established ? " (established member, reduced sensitivity)" : ""}`);
+      weight += established ? Math.round(20 * leniency.weightMultiplier) : 20;
     }
-    if (buf.dupCount >= cfg.spam.duplicateThreshold) {
-      reasons.push(`duplicate flood x${buf.dupCount}`);
-      weight += 20;
+    const duplicateThreshold = established ? Math.ceil(cfg.spam.duplicateThreshold * leniency.thresholdMultiplier) : cfg.spam.duplicateThreshold;
+    if (buf.dupCount >= duplicateThreshold) {
+      reasons.push(`duplicate flood x${buf.dupCount}${established ? " (established member, reduced sensitivity)" : ""}`);
+      weight += established ? Math.round(20 * leniency.weightMultiplier) : 20;
     }
+
+    // Everything below is about message CONTENT, not sending frequency -
+    // full strength regardless of tenure, since how long an account has
+    // existed says nothing about whether THIS message is dangerous.
     if (mentionCount >= cfg.mentionSpam.maxMentionsPerMessage) {
       reasons.push(`mention spam (${mentionCount})`);
       weight += 25;
+      contentSignalFired = true;
     }
     // A single @everyone/@here reaches every member at once - much higher
     // impact than several individual mentions, so it's weighted heavier and
@@ -68,18 +82,22 @@ class BasicSecurityLayer extends Layer {
     if (message.mentions.everyone && trust !== "HIGH" && trust !== "PROTECTED") {
       reasons.push("@everyone/@here mention from a non-trusted member");
       weight += 50;
+      contentSignalFired = true;
     }
     if (classification.scam >= cfg.nlp.scamScoreThreshold) {
       reasons.push(`scam language (${classification.scam.toFixed(2)})`);
       weight += 35;
+      contentSignalFired = true;
     }
     if (classification.phishing >= cfg.nlp.phishingScoreThreshold) {
       reasons.push(`phishing language (${classification.phishing.toFixed(2)})`);
       weight += 35;
+      contentSignalFired = true;
     }
     if (classification.raidCallout >= cfg.nlp.raidCalloutThreshold) {
       reasons.push(`raid-recruitment language (${classification.raidCallout.toFixed(2)})`);
       weight += 35;
+      contentSignalFired = true;
     }
     // The specific pattern in a lot of real raid-tool spam: an invite link
     // to another server, paired with language recruiting people to raid
@@ -90,10 +108,12 @@ class BasicSecurityLayer extends Layer {
     if (hasInvite && classification.raidCallout >= cfg.nlp.raidCalloutThreshold && trust !== "HIGH" && trust !== "PROTECTED") {
       reasons.push("Discord invite link paired with raid-recruitment language");
       weight += 50;
+      contentSignalFired = true;
     }
     if (linkFlag) {
       reasons.push(linkFlag);
       weight += 30;
+      contentSignalFired = true;
     }
 
     if (!reasons.length) {
@@ -101,10 +121,22 @@ class BasicSecurityLayer extends Layer {
       return;
     }
 
-    try {
-      if (message.deletable) await message.delete();
-    } catch {
-      /* best effort - still report the signal even if delete fails */
+    // Never delete a recognized admin/staff member's message over a
+    // heuristic - they'll be flagged for review if warranted (see
+    // PunishmentEngine's trust gating), but the message itself stays up.
+    // Same treatment for an established member who ONLY tripped a rate/
+    // volume signal (just a very active regular, not a raider) - but if a
+    // CONTENT signal fired too, the message comes down regardless of
+    // tenure, since a long-standing account can still post something
+    // genuinely dangerous.
+    const isProtectedTrust = trust === "HIGH" || trust === "PROTECTED";
+    const softenedForTenure = established && !contentSignalFired;
+    if (!isProtectedTrust && !softenedForTenure) {
+      try {
+        if (message.deletable) await message.delete();
+      } catch {
+        /* best effort - still report the signal even if delete fails */
+      }
     }
 
     await this.frame.punishmentEngine.report({

package/dist/src/moderation/RoleAnalyzer.js

@@ -39,6 +39,32 @@ class RoleAnalyzer {
     return "LOW";
   }
 
+  /**
+   * A DIFFERENT question from trustLevel() above: not "does this member
+   * hold real authority," but "has this account and this membership simply
+   * existed long enough to not look like a fresh raid/alt account." No
+   * relation to roles or permissions - a totally ordinary member with no
+   * special role can be "established," and a MEDIUM-trust role holder with
+   * a week-old account isn't.
+   *
+   * This exists to soften pure rate/volume spam detection (see
+   * BasicSecurityLayer) for members who are simply very active, the way
+   * modern invisible CAPTCHA judges from signals already available instead
+   * of a one-size-fits-all challenge - it is deliberately NOT used to
+   * soften content-based detection (scam/phishing/raid language, links),
+   * since account age says nothing about whether a specific message is
+   * dangerous. An established account can still raid or spam; this only
+   * ever reduces false positives on "sends a lot of messages," never
+   * blanket-exempts anyone from everything else.
+   */
+  isEstablishedMember(member) {
+    if (!member || !member.user) return false;
+    const cfg = this.config.maturity;
+    const accountAge = Date.now() - member.user.createdTimestamp;
+    const serverTenure = member.joinedTimestamp ? Date.now() - member.joinedTimestamp : 0;
+    return accountAge >= cfg.minAccountAgeMs && serverTenure >= cfg.minServerTenureMs;
+  }
+
   /**
    * Scans a guild's current roles for name/permission mismatches: a role
    * whose name signals authority ("admin", "staff", ...) but carries no real

package/docs/PROTOCOL_LAYERS.md

@@ -132,3 +132,27 @@ frame.registerAction("addMutedRole", async (member) => {
 ```js
 config: { punishment: { ladder: { medium: "addMutedRole" } } }
 ```
+
+## Established-member leniency
+
+A separate axis from role-based trust, for a question role trust can't
+answer: not "does this member have authority," but "has this account and
+this membership simply existed long enough to not look like a fresh raid
+account." `RoleAnalyzer.isEstablishedMember(member)` checks account age and
+server tenure against `roleAnalysis.maturity` (defaults: 6 months, 1
+month). A totally ordinary member with no special role can be
+"established"; a MEDIUM-trust role holder with a week-old account isn't.
+
+`BasicSecurityLayer` is the only place this is used, and only for the two
+pure rate/volume checks (message rate, duplicate flood) -
+`basicSecurity.establishedMemberLeniency` raises the threshold before
+either fires at all and reduces the weight when it does, and neither
+deletes an established member's message on its own. Every content-based
+check (scam/phishing/raid-recruitment language, links, non-trusted mass
+pings) is completely unaffected by tenure - full threshold, full weight,
+message still deleted - since how long an account has existed says nothing
+about whether a specific message is dangerous. This is deliberate: the
+point is recognizing "this is just a very active regular," not granting
+immunity. An established account can still raid, spam, or get compromised,
+and will still be caught the moment it does anything content-wise, not
+just volume-wise.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glassframe-protocol",
-  "version": "2.1.0",
+  "version": "2.2.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": [