refactor(outbound): split recovery counters and normalize legacy retry entries

src/infra/outbound/outbound.test.ts

@@ -11,6 +11,7 @@ import {
   type DeliverFn,
   enqueueDelivery,
   failDelivery,
+  isEntryEligibleForRecoveryRetry,
   isPermanentDeliveryError,
   loadPendingDeliveries,
   MAX_RETRIES,
@@ -183,6 +184,25 @@ describe("delivery-queue", () => {
       const entries = await loadPendingDeliveries(tmpDir);
       expect(entries).toHaveLength(2);
     });
+
+    it("backfills lastAttemptAt for legacy retry entries during load", async () => {
+      const id = await enqueueDelivery(
+        { channel: "whatsapp", to: "+1", payloads: [{ text: "legacy" }] },
+        tmpDir,
+      );
+      const filePath = path.join(tmpDir, "delivery-queue", `${id}.json`);
+      const legacyEntry = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      legacyEntry.retryCount = 2;
+      delete legacyEntry.lastAttemptAt;
+      fs.writeFileSync(filePath, JSON.stringify(legacyEntry), "utf-8");
+
+      const entries = await loadPendingDeliveries(tmpDir);
+      expect(entries).toHaveLength(1);
+      expect(entries[0]?.lastAttemptAt).toBe(entries[0]?.enqueuedAt);
+
+      const persisted = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      expect(persisted.lastAttemptAt).toBe(persisted.enqueuedAt);
+    });
   });
 
   describe("computeBackoffMs", () => {
@@ -205,6 +225,45 @@ describe("delivery-queue", () => {
     });
   });
 
+  describe("isEntryEligibleForRecoveryRetry", () => {
+    it("allows first replay after crash for retryCount=0 without lastAttemptAt", () => {
+      const now = Date.now();
+      const result = isEntryEligibleForRecoveryRetry(
+        {
+          id: "entry-1",
+          channel: "whatsapp",
+          to: "+1",
+          payloads: [{ text: "a" }],
+          enqueuedAt: now,
+          retryCount: 0,
+        },
+        now,
+      );
+      expect(result).toEqual({ eligible: true });
+    });
+
+    it("defers retry entries until backoff window elapses", () => {
+      const now = Date.now();
+      const result = isEntryEligibleForRecoveryRetry(
+        {
+          id: "entry-2",
+          channel: "whatsapp",
+          to: "+1",
+          payloads: [{ text: "a" }],
+          enqueuedAt: now - 30_000,
+          retryCount: 3,
+          lastAttemptAt: now,
+        },
+        now,
+      );
+      expect(result.eligible).toBe(false);
+      if (result.eligible) {
+        throw new Error("Expected ineligible retry entry");
+      }
+      expect(result.remainingBackoffMs).toBeGreaterThan(0);
+    });
+  });
+
   describe("recoverPendingDeliveries", () => {
     const baseCfg = {};
     const createLog = () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn() });
@@ -257,7 +316,8 @@ describe("delivery-queue", () => {
       expect(deliver).toHaveBeenCalledTimes(2);
       expect(result.recovered).toBe(2);
       expect(result.failed).toBe(0);
-      expect(result.skipped).toBe(0);
+      expect(result.skippedMaxRetries).toBe(0);
+      expect(result.deferredBackoff).toBe(0);
 
       // Queue should be empty after recovery.
       const remaining = await loadPendingDeliveries(tmpDir);
@@ -276,7 +336,8 @@ describe("delivery-queue", () => {
       const { result } = await runRecovery({ deliver });
 
       expect(deliver).not.toHaveBeenCalled();
-      expect(result.skipped).toBe(1);
+      expect(result.skippedMaxRetries).toBe(1);
+      expect(result.deferredBackoff).toBe(0);
 
       // Entry should be in failed/ directory.
       const failedDir = path.join(tmpDir, "delivery-queue", "failed");
@@ -376,7 +437,8 @@ describe("delivery-queue", () => {
       expect(deliver).not.toHaveBeenCalled();
       expect(result.recovered).toBe(0);
       expect(result.failed).toBe(0);
-      expect(result.skipped).toBe(0);
+      expect(result.skippedMaxRetries).toBe(0);
+      expect(result.deferredBackoff).toBe(0);
 
       // All entries should still be in the queue.
       const remaining = await loadPendingDeliveries(tmpDir);
@@ -400,7 +462,12 @@ describe("delivery-queue", () => {
       });
 
       expect(deliver).not.toHaveBeenCalled();
-      expect(result).toEqual({ recovered: 0, failed: 0, skipped: 0 });
+      expect(result).toEqual({
+        recovered: 0,
+        failed: 0,
+        skippedMaxRetries: 0,
+        deferredBackoff: 1,
+      });
 
       const remaining = await loadPendingDeliveries(tmpDir);
       expect(remaining).toHaveLength(1);
@@ -425,7 +492,12 @@ describe("delivery-queue", () => {
       const deliver = vi.fn().mockResolvedValue([]);
       const { result } = await runRecovery({ deliver, maxRecoveryMs: 60_000 });
 
-      expect(result).toEqual({ recovered: 1, failed: 0, skipped: 0 });
+      expect(result).toEqual({
+        recovered: 1,
+        failed: 0,
+        skippedMaxRetries: 0,
+        deferredBackoff: 1,
+      });
       expect(deliver).toHaveBeenCalledTimes(1);
       expect(deliver).toHaveBeenCalledWith(
         expect.objectContaining({ channel: "telegram", to: "2", skipQueue: true }),
@@ -449,13 +521,23 @@ describe("delivery-queue", () => {
 
       const firstDeliver = vi.fn().mockResolvedValue([]);
       const firstRun = await runRecovery({ deliver: firstDeliver, maxRecoveryMs: 60_000 });
-      expect(firstRun.result).toEqual({ recovered: 0, failed: 0, skipped: 0 });
+      expect(firstRun.result).toEqual({
+        recovered: 0,
+        failed: 0,
+        skippedMaxRetries: 0,
+        deferredBackoff: 1,
+      });
       expect(firstDeliver).not.toHaveBeenCalled();
 
       vi.setSystemTime(new Date(start.getTime() + 600_000 + 1));
       const secondDeliver = vi.fn().mockResolvedValue([]);
       const secondRun = await runRecovery({ deliver: secondDeliver, maxRecoveryMs: 60_000 });
-      expect(secondRun.result).toEqual({ recovered: 1, failed: 0, skipped: 0 });
+      expect(secondRun.result).toEqual({
+        recovered: 1,
+        failed: 0,
+        skippedMaxRetries: 0,
+        deferredBackoff: 0,
+      });
       expect(secondDeliver).toHaveBeenCalledTimes(1);
 
       const remaining = await loadPendingDeliveries(tmpDir);
@@ -468,7 +550,12 @@ describe("delivery-queue", () => {
       const deliver = vi.fn();
       const { result } = await runRecovery({ deliver });
 
-      expect(result).toEqual({ recovered: 0, failed: 0, skipped: 0 });
+      expect(result).toEqual({
+        recovered: 0,
+        failed: 0,
+        skippedMaxRetries: 0,
+        deferredBackoff: 0,
+      });
       expect(deliver).not.toHaveBeenCalled();
     });
   });