1. src/rules/account/age.ts:8-22 - renamed ReplyContext → InteractionContext, added quotedDid and quotedPostURI fields for quote posts, actorDid as the common actor field 2. src/rules/account/age.ts:123-149 - updated matching logic to check both replies (replyToDid/replyToPostURI) AND quotes (quotedDid/quotedPostURI) 3. src/rules/account/ageConstants.ts:3-12 - updated documentation to reflect reply/quote monitoring 4. added 4 new tests covering: - labeling when quoting monitored DID - labeling when quoting monitored post URI - not labeling when quoting different DID - matching either reply OR quote to monitored target

src/rules/account/age.ts

···
 import { PLC_URL } from "../../config.js";
 import { GLOBAL_ALLOW } from "../../constants.js";
 
-interface ReplyContext {
-  replyToDid: string;
-  replyingDid: string;
-  atURI: string;
-  time: number;
+interface InteractionContext {
+  // For replies
+  replyToDid?: string;
+  replyingDid?: string;
   replyToPostURI?: string; // The URI of the post being replied to (optional)
+
+  // For quote posts
+  quotedDid?: string; // DID of the account whose post is being quoted
+  quotedPostURI?: string; // URI of the post being quoted
+
+  // Common fields (required)
+  actorDid: string; // The DID performing the action (replying or quoting)
+  atURI: string; // URI of the reply or quote post
+  time: number;
 }
 
 /**
···
 };
 
 /**
- * Checks if a reply meets age criteria and applies labels accordingly
+ * Checks if a reply or quote post meets age criteria and applies labels accordingly
  */
-export const checkAccountAge = async (context: ReplyContext): Promise<void> => {
+export const checkAccountAge = async (
+  context: InteractionContext,
+): Promise<void> => {
   // Skip if no checks configured
   if (ACCOUNT_AGE_CHECKS.length === 0) {
     return;
   }
 
   // Skip if DID is globally allowlisted
-  if (GLOBAL_ALLOW.includes(context.replyingDid)) {
+  if (GLOBAL_ALLOW.includes(context.actorDid)) {
     logger.debug(
       {
         process: "ACCOUNT_AGE",
-        did: context.replyingDid,
+        did: context.actorDid,
         atURI: context.atURI,
       },
       "Global allowlisted DID",
···
 
   // Check each configuration
   for (const check of ACCOUNT_AGE_CHECKS) {
-    // Check if this reply matches monitored DIDs or post URIs
-    const matchesDID =
-      check.monitoredDIDs && check.monitoredDIDs.includes(context.replyToDid);
-    const matchesPostURI =
+    // Check if this interaction matches monitored DIDs or post URIs
+    // For replies: check replyToDid and replyToPostURI
+    // For quotes: check quotedDid and quotedPostURI
+    const matchesReplyDID =
+      check.monitoredDIDs &&
+      context.replyToDid &&
+      check.monitoredDIDs.includes(context.replyToDid);
+    const matchesReplyPostURI =
       check.monitoredPostURIs &&
       context.replyToPostURI &&
       check.monitoredPostURIs.includes(context.replyToPostURI);
+    const matchesQuoteDID =
+      check.monitoredDIDs &&
+      context.quotedDid &&
+      check.monitoredDIDs.includes(context.quotedDid);
+    const matchesQuotePostURI =
+      check.monitoredPostURIs &&
+      context.quotedPostURI &&
+      check.monitoredPostURIs.includes(context.quotedPostURI);
 
-    if (!matchesDID && !matchesPostURI) {
+    if (
+      !matchesReplyDID &&
+      !matchesReplyPostURI &&
+      !matchesQuoteDID &&
+      !matchesQuotePostURI
+    ) {
       continue;
     }
 
···
     logger.debug(
       {
         process: "ACCOUNT_AGE",
-        replyingDid: context.replyingDid,
+        actorDid: context.actorDid,
         replyToDid: context.replyToDid,
+        quotedDid: context.quotedDid,
       },
-      "Checking account age for reply to monitored DID",
+      "Checking account age for interaction with monitored target",
     );
 
     // Get account creation date
-    const creationDate = await getAccountCreationDate(context.replyingDid);
+    const creationDate = await getAccountCreationDate(context.actorDid);
     if (!creationDate) {
       logger.warn(
         {
           process: "ACCOUNT_AGE",
-          replyingDid: context.replyingDid,
+          actorDid: context.actorDid,
         },
         "Could not determine creation date, skipping",
       );
···
     logger.debug(
       {
         process: "ACCOUNT_AGE",
-        replyingDid: context.replyingDid,
+        actorDid: context.actorDid,
         creationDate: creationDate.toISOString(),
         windowStart: windowStart.toISOString(),
         windowEnd: windowEnd.toISOString(),
···
     if (creationDate >= windowStart && creationDate <= windowEnd) {
       // Check if the label already exists to prevent duplicates
       const labelExists = await checkAccountLabels(
-        context.replyingDid,
+        context.actorDid,
         check.label,
       );
 
···
         logger.debug(
           {
             process: "ACCOUNT_AGE",
-            replyingDid: context.replyingDid,
+            actorDid: context.actorDid,
             label: check.label,
           },
           "Label already exists, skipping duplicate",
         );
-        // Only apply one label per reply
+        // Only apply one label per interaction
         return;
       }
 
       logger.info(
         {
           process: "ACCOUNT_AGE",
-          replyingDid: context.replyingDid,
+          actorDid: context.actorDid,
           replyToDid: context.replyToDid,
+          quotedDid: context.quotedDid,
           atURI: context.atURI,
         },
         "Labeling account created within the monitored date range",
       );
 
       await createAccountLabel(
-        context.replyingDid,
+        context.actorDid,
         check.label,
-        `${context.time}: ${check.comment} - Account created within monitored range - Reply: ${context.atURI}`,
+        `${context.time}: ${check.comment} - Account created within monitored range - Interaction: ${context.atURI}`,
       );
 
-      // Only apply one label per reply
+      // Only apply one label per interaction
       return;
     }
   }

src/rules/account/ageConstants.ts

···
 /**
  * Account age monitoring configurations
  *
- * Each configuration monitors replies to specified DIDs and labels accounts
- * that are newer than the threshold relative to the anchor date.
+ * Each configuration monitors replies and/or quote posts to specified DIDs or posts
+ * and labels accounts that were created within a specific time window.
  *
- * Example use case:
- * - Monitor replies to high-profile accounts during harassment campaigns
+ * Example use cases:
+ * - Monitor replies/quotes to high-profile accounts during harassment campaigns
  * - Flag sock puppet accounts created to participate in coordinated harassment
+ * - Detect brigading on specific controversial posts
  */
 export const ACCOUNT_AGE_CHECKS: AccountAgeCheck[] = [
   // Example: Monitor replies to specific accounts

src/rules/account/tests/age.test.ts

···
 
     it("should skip if no checks configured", async () => {
       await checkAccountAge({
+        actorDid: "did:plc:replier",
         replyToDid: "did:plc:monitored",
-        replyingDid: "did:plc:replier",
         atURI: TEST_REPLY_URI,
         time: TEST_TIME,
       });
···
       });
 
       await checkAccountAge({
+        actorDid: "did:plc:replier",
         replyToDid: "did:plc:other",
         replyingDid: "did:plc:replier",
         atURI: TEST_REPLY_URI,
···
         });
 
         await checkAccountAge({
-          replyToDid: "did:plc:monitored",
+          actorDid: "did:plc:inwindow",
+        replyToDid: "did:plc:monitored",
           replyingDid: "did:plc:inwindow",
           atURI: TEST_REPLY_URI,
           time: TEST_TIME,
···
         });
 
         await checkAccountAge({
-          replyToDid: "did:plc:monitored",
+          actorDid: "did:plc:beforewindow",
+        replyToDid: "did:plc:monitored",
           replyingDid: "did:plc:beforewindow",
           atURI: TEST_REPLY_URI,
           time: TEST_TIME,
···
         });
 
         await checkAccountAge({
-          replyToDid: "did:plc:monitored",
+          actorDid: "did:plc:afterwindow",
+        replyToDid: "did:plc:monitored",
           replyingDid: "did:plc:afterwindow",
           atURI: TEST_REPLY_URI,
           time: TEST_TIME,
···
         });
 
         await checkAccountAge({
-          replyToDid: "did:plc:monitored",
+          actorDid: "did:plc:startofwindow",
+        replyToDid: "did:plc:monitored",
           replyingDid: "did:plc:startofwindow",
           atURI: TEST_REPLY_URI,
           time: TEST_TIME,
···
         });
 
         await checkAccountAge({
-          replyToDid: "did:plc:monitored",
+          actorDid: "did:plc:endofwindow",
+        replyToDid: "did:plc:monitored",
           replyingDid: "did:plc:endofwindow",
           atURI: TEST_REPLY_URI,
           time: TEST_TIME,
···
       });
 
       await checkAccountAge({
+        actorDid: "did:plc:unknown",
         replyToDid: "did:plc:monitored",
         replyingDid: "did:plc:unknown",
         atURI: TEST_REPLY_URI,
···
       });
 
       await checkAccountAge({
+        actorDid: "did:plc:newaccount",
         replyToDid: "did:plc:monitored",
         replyingDid: "did:plc:newaccount",
         atURI: TEST_REPLY_URI,
···
       (checkAccountLabels as any).mockResolvedValueOnce(true);
 
       await checkAccountAge({
+        actorDid: "did:plc:alreadylabeled",
         replyToDid: "did:plc:monitored",
         replyingDid: "did:plc:alreadylabeled",
         atURI: TEST_REPLY_URI,
···
       expect(logger.debug).toHaveBeenCalledWith(
         {
           process: "ACCOUNT_AGE",
-          replyingDid: "did:plc:alreadylabeled",
+          actorDid: "did:plc:alreadylabeled",
           label: "window-reply",
         },
         "Label already exists, skipping duplicate",
···
       (checkAccountLabels as any).mockResolvedValueOnce(false);
 
       await checkAccountAge({
+        actorDid: "did:plc:newlabel",
         replyToDid: "did:plc:monitored",
         replyingDid: "did:plc:newlabel",
         atURI: TEST_REPLY_URI,
···
       GLOBAL_ALLOW.push("did:plc:allowlisted");
 
       await checkAccountAge({
+        actorDid: "did:plc:allowlisted",
         replyToDid: "did:plc:monitored",
         replyingDid: "did:plc:allowlisted",
         atURI: TEST_REPLY_URI,
···
       });
 
       await checkAccountAge({
+        actorDid: "did:plc:newaccount",
         replyToDid: "did:plc:monitored",
         replyingDid: "did:plc:newaccount",
         atURI: TEST_REPLY_URI,
···
       (checkAccountLabels as any).mockResolvedValueOnce(false);
 
       await checkAccountAge({
+        actorDid: "did:plc:newaccount",
         replyToDid: "did:plc:monitored",
         replyingDid: "did:plc:newaccount",
         atURI: TEST_REPLY_URI,
···
       (checkAccountLabels as any).mockResolvedValueOnce(false);
 
       await checkAccountAge({
+        actorDid: "did:plc:newaccount",
         replyToDid: "did:plc:monitored",
         replyingDid: "did:plc:newaccount",
         atURI: TEST_REPLY_URI,
···
       (checkAccountLabels as any).mockResolvedValueOnce(false);
 
       await checkAccountAge({
+        actorDid: "did:plc:newaccount",
         replyToDid: "did:plc:someone",
         replyingDid: "did:plc:newaccount",
         atURI: TEST_REPLY_URI,
···
       });
 
       await checkAccountAge({
+        actorDid: "did:plc:newaccount",
         replyToDid: "did:plc:someone",
         replyingDid: "did:plc:newaccount",
         atURI: TEST_REPLY_URI,
···
 
       // Test matching by post URI even though DID doesn't match
       await checkAccountAge({
+        actorDid: "did:plc:newaccount",
         replyToDid: "did:plc:someone-else",
         replyingDid: "did:plc:newaccount",
         atURI: TEST_REPLY_URI,
···
       (checkAccountLabels as any).mockResolvedValueOnce(false);
 
       await checkAccountAge({
+        actorDid: "did:plc:newaccount",
         replyToDid: "did:plc:monitored",
         replyingDid: "did:plc:newaccount",
         atURI: TEST_REPLY_URI,
···
       expect(createAccountLabel).toHaveBeenCalledWith(
         "did:plc:newaccount",
         "window-reply",
+        expect.stringContaining("Account created within monitored range"),
+      );
+    });
+
+    it("should label account when quoting a monitored DID", async () => {
+      ACCOUNT_AGE_CHECKS.push({
+        monitoredDIDs: ["did:plc:monitored"],
+        anchorDate: "2025-10-15",
+        maxAgeDays: 7,
+        label: "quote-brigading",
+        comment: "New account quote-posting monitored user",
+      });
+
+      // Mock account created within window
+      const mockDidDoc = [{ createdAt: "2025-10-18T12:00:00.000Z" }];
+      (global.fetch as any).mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockDidDoc,
+      });
+
+      // Mock that label does NOT exist
+      (checkAccountLabels as any).mockResolvedValueOnce(false);
+
+      await checkAccountAge({
+        actorDid: "did:plc:quoter",
+        quotedDid: "did:plc:monitored",
+        atURI: "at://did:plc:quoter/app.bsky.feed.post/quote123",
+        time: TEST_TIME,
+      });
+
+      expect(createAccountLabel).toHaveBeenCalledWith(
+        "did:plc:quoter",
+        "quote-brigading",
+        expect.stringContaining("Account created within monitored range"),
+      );
+    });
+
+    it("should label account when quoting a monitored post URI", async () => {
+      ACCOUNT_AGE_CHECKS.push({
+        monitoredPostURIs: [
+          "at://did:plc:target/app.bsky.feed.post/targeted",
+        ],
+        anchorDate: "2025-10-15",
+        maxAgeDays: 7,
+        label: "brigading-suspect",
+        comment: "New account quoting targeted post",
+      });
+
+      // Mock account created within window
+      const mockDidDoc = [{ createdAt: "2025-10-18T12:00:00.000Z" }];
+      (global.fetch as any).mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockDidDoc,
+      });
+
+      // Mock that label does NOT exist
+      (checkAccountLabels as any).mockResolvedValueOnce(false);
+
+      await checkAccountAge({
+        actorDid: "did:plc:quoter",
+        quotedPostURI: "at://did:plc:target/app.bsky.feed.post/targeted",
+        atURI: "at://did:plc:quoter/app.bsky.feed.post/quote456",
+        time: TEST_TIME,
+      });
+
+      expect(createAccountLabel).toHaveBeenCalledWith(
+        "did:plc:quoter",
+        "brigading-suspect",
+        expect.stringContaining("Account created within monitored range"),
+      );
+    });
+
+    it("should not label when quoting different DID", async () => {
+      ACCOUNT_AGE_CHECKS.push({
+        monitoredDIDs: ["did:plc:monitored"],
+        anchorDate: "2025-10-15",
+        maxAgeDays: 7,
+        label: "quote-brigading",
+        comment: "New account quote-posting",
+      });
+
+      // Mock account created within window
+      const mockDidDoc = [{ createdAt: "2025-10-18T12:00:00.000Z" }];
+      (global.fetch as any).mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockDidDoc,
+      });
+
+      await checkAccountAge({
+        actorDid: "did:plc:quoter",
+        quotedDid: "did:plc:different",
+        atURI: "at://did:plc:quoter/app.bsky.feed.post/quote789",
+        time: TEST_TIME,
+      });
+
+      expect(createAccountLabel).not.toHaveBeenCalled();
+    });
+
+    it("should match either reply or quote to monitored DID", async () => {
+      ACCOUNT_AGE_CHECKS.push({
+        monitoredDIDs: ["did:plc:monitored"],
+        anchorDate: "2025-10-15",
+        maxAgeDays: 7,
+        label: "interaction-suspect",
+        comment: "New account interacting with monitored user",
+      });
+
+      // Mock account created within window
+      const mockDidDoc = [{ createdAt: "2025-10-18T12:00:00.000Z" }];
+      (global.fetch as any).mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockDidDoc,
+      });
+
+      // Mock that label does NOT exist
+      (checkAccountLabels as any).mockResolvedValueOnce(false);
+
+      // Test quote (not reply) to monitored DID
+      await checkAccountAge({
+        actorDid: "did:plc:actor",
+        quotedDid: "did:plc:monitored",
+        atURI: "at://did:plc:actor/app.bsky.feed.post/interaction",
+        time: TEST_TIME,
+      });
+
+      expect(createAccountLabel).toHaveBeenCalledWith(
+        "did:plc:actor",
+        "interaction-suspect",
         expect.stringContaining("Account created within monitored range"),
       );
     });