feat: Add check to avoid duplicate account age labels

This commit adds a check to the `checkAccountAge` function to prevent
duplicate labels from being applied to the same account. It uses the
`checkAccountLabels` function to determine if a label already exists
before attempting to create a new one. This prevents redundant labeling
and improves efficiency. Also includes unit tests for the
`checkAccountLabels` function to ensure correct behavior.

src/rules/account/age.ts

···
 import { agent, isLoggedIn } from "../../agent.js";
 import { logger } from "../../logger.js";
-import { createAccountLabel } from "../../moderation.js";
+import { createAccountLabel, checkAccountLabels } from "../../moderation.js";
 import { ACCOUNT_AGE_CHECKS } from "./ageConstants.js";
 import { PLC_URL } from "../../config.js";
 import { GLOBAL_ALLOW } from "../../constants.js";
···
 
     // Check if account was created within the window
     if (creationDate >= windowStart && creationDate <= windowEnd) {
+      // Check if the label already exists to prevent duplicates
+      const labelExists = await checkAccountLabels(
+        context.replyingDid,
+        check.label,
+      );
+
+      if (labelExists) {
+        logger.debug(
+          {
+            process: "ACCOUNT_AGE",
+            replyingDid: context.replyingDid,
+            label: check.label,
+          },
+          "Label already exists, skipping duplicate",
+        );
+        // Only apply one label per reply
+        return;
+      }
+
       logger.info(
         {
           process: "ACCOUNT_AGE",

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

···
 
 vi.mock("../../../moderation.js", () => ({
   createAccountLabel: vi.fn(),
+  checkAccountLabels: vi.fn(),
 }));
 
 vi.mock("../../../constants.js", () => ({
···
 
 import { agent } from "../../../agent.js";
 import { logger } from "../../../logger.js";
-import { createAccountLabel } from "../../../moderation.js";
+import {
+  createAccountLabel,
+  checkAccountLabels,
+} from "../../../moderation.js";
 import { GLOBAL_ALLOW } from "../../../constants.js";
 
 describe("Account Age Module", () => {
···
         "did:plc:newaccount",
         "label1",
         expect.any(String),
+      );
+    });
+
+    it("should skip labeling if label already exists on account", async () => {
+      ACCOUNT_AGE_CHECKS.push({
+        monitoredDIDs: ["did:plc:monitored"],
+        anchorDate: "2025-10-15",
+        maxAgeDays: 7,
+        label: "window-reply",
+        comment: "Account created in window",
+      });
+
+      // 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 already exists
+      (checkAccountLabels as any).mockResolvedValueOnce(true);
+
+      await checkAccountAge({
+        replyToDid: "did:plc:monitored",
+        replyingDid: "did:plc:alreadylabeled",
+        atURI: TEST_REPLY_URI,
+        time: TEST_TIME,
+      });
+
+      expect(checkAccountLabels).toHaveBeenCalledWith(
+        "did:plc:alreadylabeled",
+        "window-reply",
+      );
+      expect(createAccountLabel).not.toHaveBeenCalled();
+      expect(logger.debug).toHaveBeenCalledWith(
+        {
+          process: "ACCOUNT_AGE",
+          replyingDid: "did:plc:alreadylabeled",
+          label: "window-reply",
+        },
+        "Label already exists, skipping duplicate",
+      );
+    });
+
+    it("should create label if it does not already exist", async () => {
+      ACCOUNT_AGE_CHECKS.push({
+        monitoredDIDs: ["did:plc:monitored"],
+        anchorDate: "2025-10-15",
+        maxAgeDays: 7,
+        label: "window-reply",
+        comment: "Account created in window",
+      });
+
+      // 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({
+        replyToDid: "did:plc:monitored",
+        replyingDid: "did:plc:newlabel",
+        atURI: TEST_REPLY_URI,
+        time: TEST_TIME,
+      });
+
+      expect(checkAccountLabels).toHaveBeenCalledWith(
+        "did:plc:newlabel",
+        "window-reply",
+      );
+      expect(createAccountLabel).toHaveBeenCalledWith(
+        "did:plc:newlabel",
+        "window-reply",
+        expect.stringContaining("Account created within monitored range"),
       );
     });
 

src/tests/moderation.test.ts

···
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { checkAccountLabels } from "../moderation.js";
+
+// Mock dependencies
+vi.mock("../agent.js", () => ({
+  agent: {
+    tools: {
+      ozone: {
+        moderation: {
+          getRepo: vi.fn(),
+        },
+      },
+    },
+  },
+  isLoggedIn: Promise.resolve(true),
+}));
+
+vi.mock("../logger.js", () => ({
+  logger: {
+    info: vi.fn(),
+    debug: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+vi.mock("../config.js", () => ({
+  MOD_DID: "did:plc:moderator123",
+}));
+
+vi.mock("../limits.js", () => ({
+  limit: vi.fn((fn) => fn()),
+}));
+
+import { agent } from "../agent.js";
+import { logger } from "../logger.js";
+
+describe("checkAccountLabels", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should return true if label exists on account", async () => {
+    (agent.tools.ozone.moderation.getRepo as any).mockResolvedValueOnce({
+      data: {
+        labels: [
+          { val: "spam" },
+          { val: "harassment" },
+          { val: "window-reply" },
+        ],
+      },
+    });
+
+    const result = await checkAccountLabels(
+      "did:plc:test123",
+      "window-reply",
+    );
+
+    expect(result).toBe(true);
+    expect(agent.tools.ozone.moderation.getRepo).toHaveBeenCalledWith(
+      { did: "did:plc:test123" },
+      {
+        headers: {
+          "atproto-proxy": "did:plc:moderator123#atproto_labeler",
+          "atproto-accept-labelers":
+            "did:plc:ar7c4by46qjdydhdevvrndac;redact",
+        },
+      },
+    );
+  });
+
+  it("should return false if label does not exist on account", async () => {
+    (agent.tools.ozone.moderation.getRepo as any).mockResolvedValueOnce({
+      data: {
+        labels: [{ val: "spam" }, { val: "harassment" }],
+      },
+    });
+
+    const result = await checkAccountLabels(
+      "did:plc:test123",
+      "window-reply",
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false if account has no labels", async () => {
+    (agent.tools.ozone.moderation.getRepo as any).mockResolvedValueOnce({
+      data: {
+        labels: [],
+      },
+    });
+
+    const result = await checkAccountLabels(
+      "did:plc:test123",
+      "window-reply",
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false if labels property is undefined", async () => {
+    (agent.tools.ozone.moderation.getRepo as any).mockResolvedValueOnce({
+      data: {},
+    });
+
+    const result = await checkAccountLabels(
+      "did:plc:test123",
+      "window-reply",
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it("should handle API errors gracefully", async () => {
+    (agent.tools.ozone.moderation.getRepo as any).mockRejectedValueOnce(
+      new Error("API Error"),
+    );
+
+    const result = await checkAccountLabels(
+      "did:plc:test123",
+      "window-reply",
+    );
+
+    expect(result).toBe(false);
+    expect(logger.error).toHaveBeenCalledWith(
+      {
+        process: "MODERATION",
+        did: "did:plc:test123",
+        error: expect.any(Error),
+      },
+      "Failed to check account labels",
+    );
+  });
+
+  it("should perform case-sensitive label matching", async () => {
+    (agent.tools.ozone.moderation.getRepo as any).mockResolvedValueOnce({
+      data: {
+        labels: [{ val: "window-reply" }],
+      },
+    });
+
+    const resultLower = await checkAccountLabels(
+      "did:plc:test123",
+      "window-reply",
+    );
+    expect(resultLower).toBe(true);
+
+    (agent.tools.ozone.moderation.getRepo as any).mockResolvedValueOnce({
+      data: {
+        labels: [{ val: "window-reply" }],
+      },
+    });
+
+    const resultUpper = await checkAccountLabels(
+      "did:plc:test123",
+      "Window-Reply",
+    );
+    expect(resultUpper).toBe(false);
+  });
+});