fix: eliminate fire-and-forget async patterns in moderation actions

Convert void-discarded promises to properly awaited calls with error
handling and aggregation. This prevents phantom state where Redis
succeeds but Ozone API fails.

Changes:
- Add ModerationResult type for structured error tracking
- Add moderationActionsFailedCounter metric for monitoring failures
- Modify moderation functions to rethrow errors after logging
- Update checkProfiles.ts ProfileChecker with async/await pattern
- Update checkPosts.ts to use for...of loop with proper awaiting
- Update countStarterPacks.ts with error handling

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

src/accountModeration.ts

···
         { process: "MODERATION", error: e },
         "Failed to create account label",
       );
+      throw e;
     }
   });
 };
···
         { process: "MODERATION", error: e },
         "Failed to create account comment",
       );
+      throw e;
     }
   });
 };
···
         { process: "MODERATION", error: e },
         "Failed to create account report",
       );
+      throw e;
     }
   });
 };
···
         { process: "MODERATION", error: e },
         "Failed to negate account label",
       );
+      throw e;
     }
   });
 };

src/metrics.ts

···
   registers: [register],
 });
 
+export const moderationActionsFailedCounter = new Counter({
+  name: "skywatch_moderation_actions_failed_total",
+  help: "Total number of moderation actions that failed",
+  labelNames: ["action", "target_type"],
+  registers: [register],
+});
+
 const app = express();
 
 app.get("/metrics", (req, res) => {

src/moderation.ts

···
         { process: "MODERATION", error: e },
         "Failed to create post label",
       );
+      throw e;
     }
   });
 };
···
     } catch (e) {
       logger.error(
         { process: "MODERATION", error: e },
-        "Failed to create post label",
+        "Failed to create post report",
       );
+      throw e;
     }
   });
 };

src/rules/account/countStarterPacks.ts

···
 import { agent, isLoggedIn } from "../../agent.js";
 import { limit } from "../../limits.js";
 import { logger } from "../../logger.js";
+import { moderationActionsFailedCounter } from "../../metrics.js";
 
-const ALLOWED_DIDS = [
-  "did:plc:example"
-];
+const ALLOWED_DIDS = ["did:plc:example"];
 
 export const countStarterPacks = async (did: string, time: number) => {
   await isLoggedIn;
···
           "Labeling account with excessive starter packs",
         );
 
-        void createAccountLabel(
-          did,
-          "follow-farming",
-          `${time.toString()}: Account has ${starterPacks.toString()} starter packs`,
-        );
+        try {
+          await createAccountLabel(
+            did,
+            "follow-farming",
+            `${time.toString()}: Account has ${starterPacks.toString()} starter packs`,
+          );
+        } catch (labelError) {
+          logger.error(
+            { process: "COUNTSTARTERPACKS", did, time, error: labelError },
+            "Failed to apply follow-farming label",
+          );
+          moderationActionsFailedCounter.inc({
+            action: "label",
+            target_type: "account",
+          });
+        }
       }
     } catch (error) {
       const errorInfo =

src/rules/posts/checkPosts.ts

···
 } from "../../accountModeration.js";
 import { checkAccountThreshold } from "../../accountThreshold.js";
 import { logger } from "../../logger.js";
+import { moderationActionsFailedCounter } from "../../metrics.js";
 import { createPostLabel, createPostReport } from "../../moderation.js";
-import type { Post } from "../../types.js";
+import type { ModerationResult, Post } from "../../types.js";
 import { getFinalUrl } from "../../utils/getFinalUrl.js";
 import { getLanguage } from "../../utils/getLanguage.js";
 import { countStarterPacks } from "../account/countStarterPacks.js";
···
   const lang = await getLanguage(post[0].text);
 
   // iterate through the checks
-  POST_CHECKS.forEach((checkPost) => {
+  for (const checkPost of POST_CHECKS) {
     if (checkPost.language) {
       if (!checkPost.language.includes(lang)) {
-        return;
+        continue;
       }
     }
 
···
           { process: "CHECKPOSTS", did: post[0].did, atURI: post[0].atURI },
           "Whitelisted DID",
         );
-        return;
+        continue;
       }
     }
 
···
             { process: "CHECKPOSTS", did: post[0].did, atURI: post[0].atURI },
             "Whitelisted phrase found",
           );
-          return;
+          continue;
         }
       }
 
-      void countStarterPacks(post[0].did, post[0].time);
+      await countStarterPacks(post[0].did, post[0].time);
 
       const postURL = `https://pdsls.dev/${post[0].atURI}`;
       const formattedComment = `${checkPost.comment}\n\nPost: ${postURL}\n\nText: "${post[0].text}"`;
 
+      const results: ModerationResult = { success: true, errors: [] };
+
       if (checkPost.toLabel) {
-        void createPostLabel(
-          post[0].atURI,
-          post[0].cid,
-          checkPost.label,
-          formattedComment,
-          checkPost.duration,
-          post[0].did,
-          post[0].time,
-        );
+        try {
+          await createPostLabel(
+            post[0].atURI,
+            post[0].cid,
+            checkPost.label,
+            formattedComment,
+            checkPost.duration,
+            post[0].did,
+            post[0].time,
+          );
+        } catch (error) {
+          results.success = false;
+          results.errors.push({ action: "label", error });
+        }
       } else if (checkPost.trackOnly) {
-        void checkAccountThreshold(
-          post[0].did,
-          post[0].atURI,
-          checkPost.label,
-          post[0].time,
-        );
+        try {
+          await checkAccountThreshold(
+            post[0].did,
+            post[0].atURI,
+            checkPost.label,
+            post[0].time,
+          );
+        } catch (error) {
+          // Threshold check failures are logged but don't add to results.errors
+          // since it's not a direct moderation action
+          logger.error(
+            {
+              process: "CHECKPOSTS",
+              did: post[0].did,
+              atURI: post[0].atURI,
+              error,
+            },
+            "Account threshold check failed",
+          );
+        }
       }
 
       if (checkPost.reportPost === true) {
···
           },
           "Reporting post",
         );
-        void createPostReport(post[0].atURI, post[0].cid, formattedComment);
+        try {
+          await createPostReport(post[0].atURI, post[0].cid, formattedComment);
+        } catch (error) {
+          results.success = false;
+          results.errors.push({ action: "report", error });
+        }
       }
 
       if (checkPost.reportAcct) {
···
           },
           "Reporting account",
         );
-        void createAccountReport(post[0].did, formattedComment);
+        try {
+          await createAccountReport(post[0].did, formattedComment);
+        } catch (error) {
+          results.success = false;
+          results.errors.push({ action: "report", error });
+        }
       }
 
       if (checkPost.commentAcct) {
-        void createAccountComment(post[0].did, formattedComment, post[0].atURI);
+        try {
+          await createAccountComment(
+            post[0].did,
+            formattedComment,
+            post[0].atURI,
+          );
+        } catch (error) {
+          results.success = false;
+          results.errors.push({ action: "comment", error });
+        }
+      }
+
+      // Log and track any failures
+      if (!results.success) {
+        for (const error of results.errors) {
+          logger.error(
+            {
+              process: "CHECKPOSTS",
+              did: post[0].did,
+              atURI: post[0].atURI,
+              action: error.action,
+              error: error.error,
+            },
+            "Moderation action failed",
+          );
+          moderationActionsFailedCounter.inc({
+            action: error.action,
+            target_type: "post",
+          });
+        }
       }
     }
-  });
+  }
 };

src/rules/profiles/checkProfiles.ts

···
   negateAccountLabel,
 } from "../../accountModeration.js";
 import { logger } from "../../logger.js";
-import type { Checks } from "../../types.js";
+import { moderationActionsFailedCounter } from "../../metrics.js";
+import type { Checks, ModerationResult } from "../../types.js";
 import { getLanguage } from "../../utils/getLanguage.js";
 
 export class ProfileChecker {
···
     this.time = time;
   }
 
-  checkDescription(description: string): void {
+  async checkDescription(description: string): Promise<void> {
     if (!description) return;
-    this.performActions(description, "CHECKDESCRIPTION");
+    await this.performActions(description, "CHECKDESCRIPTION");
   }
 
-  checkDisplayName(displayName: string): void {
+  async checkDisplayName(displayName: string): Promise<void> {
     if (!displayName) return;
-    this.performActions(displayName, "CHECKDISPLAYNAME");
+    await this.performActions(displayName, "CHECKDISPLAYNAME");
   }
 
-  checkBoth(displayName: string, description: string): void {
+  async checkBoth(displayName: string, description: string): Promise<void> {
     const profile = `${displayName} ${description}`;
     if (!profile) return;
-    this.performActions(profile, "CHECKPROFILE");
+    await this.performActions(profile, "CHECKPROFILE");
   }
 
-  private performActions(
+  private async performActions(
     content: string,
     processType: "CHECKPROFILE" | "CHECKDESCRIPTION" | "CHECKDISPLAYNAME",
-  ): void {
+  ): Promise<void> {
     const matched = this.check.check.test(content);
 
     if (matched) {
···
         return;
       }
 
-      this.applyActions(content, processType);
+      const result = await this.applyActions(content, processType);
+      if (!result.success) {
+        for (const error of result.errors) {
+          logger.error(
+            {
+              process: processType,
+              did: this.did,
+              action: error.action,
+              error: error.error,
+            },
+            "Moderation action failed",
+          );
+          moderationActionsFailedCounter.inc({
+            action: error.action,
+            target_type: "account",
+          });
+        }
+      }
     } else {
       if (this.check.unlabel) {
-        this.removeLabel(content, processType);
+        const result = await this.removeLabel(content, processType);
+        if (!result.success) {
+          for (const error of result.errors) {
+            logger.error(
+              {
+                process: processType,
+                did: this.did,
+                action: error.action,
+                error: error.error,
+              },
+              "Moderation action failed",
+            );
+            moderationActionsFailedCounter.inc({
+              action: error.action,
+              target_type: "account",
+            });
+          }
+        }
       }
     }
   }
 
-  private applyActions(content: string, processType: string): void {
+  private async applyActions(
+    content: string,
+    processType: string,
+  ): Promise<ModerationResult> {
+    const results: ModerationResult = { success: true, errors: [] };
     const formattedComment = `${this.time.toString()}: ${this.check.comment}\n\nContent: ${content}`;
 
     if (this.check.toLabel) {
-      void createAccountLabel(this.did, this.check.label, formattedComment);
+      try {
+        await createAccountLabel(this.did, this.check.label, formattedComment);
+      } catch (error) {
+        results.success = false;
+        results.errors.push({ action: "label", error });
+      }
     }
 
     if (this.check.reportAcct) {
-      void createAccountReport(this.did, formattedComment);
-      logger.info(
-        {
-          process: processType,
-          did: this.did,
-          time: this.time,
-          label: this.check.label,
-        },
-        "Reporting account",
-      );
+      try {
+        await createAccountReport(this.did, formattedComment);
+        logger.info(
+          {
+            process: processType,
+            did: this.did,
+            time: this.time,
+            label: this.check.label,
+          },
+          "Reporting account",
+        );
+      } catch (error) {
+        results.success = false;
+        results.errors.push({ action: "report", error });
+      }
     }
 
     if (this.check.commentAcct) {
-      void createAccountComment(
-        this.did,
-        formattedComment,
-        `profile:${this.did}`,
-      );
+      try {
+        await createAccountComment(
+          this.did,
+          formattedComment,
+          `profile:${this.did}`,
+        );
+      } catch (error) {
+        results.success = false;
+        results.errors.push({ action: "comment", error });
+      }
     }
+
+    return results;
   }
 
-  private removeLabel(content: string, _processType: string): void {
+  private async removeLabel(
+    content: string,
+    _processType: string,
+  ): Promise<ModerationResult> {
+    const results: ModerationResult = { success: true, errors: [] };
     const formattedComment = `${this.check.comment}\n\nContent: ${content}`;
-    void negateAccountLabel(this.did, this.check.label, formattedComment);
+    try {
+      await negateAccountLabel(this.did, this.check.label, formattedComment);
+    } catch (error) {
+      results.success = false;
+      results.errors.push({ action: "unlabel", error });
+    }
+    return results;
   }
 }
 
···
 
     if (checkRule.description === true) {
       const checker = new ProfileChecker(checkRule, did, time);
-      checker.checkDescription(description);
+      await checker.checkDescription(description);
     }
   }
 };
···
 
     if (checkRule.displayName === true) {
       const checker = new ProfileChecker(checkRule, did, time);
-      checker.checkDisplayName(displayName);
+      await checker.checkDisplayName(displayName);
     }
   }
 };
···
     const checker = new ProfileChecker(checkRule, did, time);
 
     if (checkRule.description === true && checkRule.displayName === true) {
-      checker.checkBoth(displayName, description);
+      await checker.checkBoth(displayName, description);
     } else if (checkRule.description === true) {
-      checker.checkDescription(description);
+      await checker.checkDescription(description);
     } else if (checkRule.displayName === true) {
-      checker.checkDisplayName(displayName);
+      await checker.checkDisplayName(displayName);
     }
   }
 };

src/types.ts

···
   commentAcct?: boolean;
   allowlist?: string[];
 }
+
+export interface ModerationError {
+  action: "label" | "report" | "comment" | "unlabel";
+  error: unknown;
+}
+
+export interface ModerationResult {
+  success: boolean;
+  errors: ModerationError[];
+}