fix(e2e): preserve exhausted cleanup evidence

Signed-off-by: Prekshi Vyas <prekshiv@nvidia.com>

Author: prekshivyas

test/e2e/RETRY_INVENTORY.md

@@ -43,7 +43,8 @@ Exhaustion remains failed.
 
 `test/e2e/fixtures/retry-policy.ts` emits schema version 1.
 The aggregate `outcome` is exactly one of `passed-first-attempt`, `passed-after-retry`, `failed-no-retry`, or `exhausted`.
-Cleanup failures use `failed-no-retry` with a final attempt whose `failureClass` is `cleanup`.
+A cleanup failure uses `failed-no-retry` when no earlier failure scheduled a retry.
+When a bounded retry reaches its final attempt and that attempt fails during cleanup, the aggregate outcome is `exhausted` and the final attempt uses `failureClass: cleanup`.
 Each attempt also records its number, failure class, reconciliation result when applicable, and whether another attempt was scheduled.
 The record deliberately excludes command output, errors, request bodies, headers, and environment values.
 Callers retain their normal redacted artifacts separately and may write the aggregate record through `onEvidence`.

test/e2e/fixtures/retry-policy.ts

@@ -176,7 +176,12 @@ export async function runBoundedRetry<T>(
       continue;
     }
 
-    const outcome = isTransient && !hasBudget ? "exhausted" : "failed-no-retry";
+    const exhaustedCleanup =
+      classification.failureClass === "cleanup" &&
+      !hasBudget &&
+      attempts.some((previous) => previous.retryScheduled);
+    const outcome =
+      (isTransient && !hasBudget) || exhaustedCleanup ? "exhausted" : "failed-no-retry";
     const evidence = finalEvidence(options, attempts, outcome);
     await emit(options, evidence);
     if (error !== undefined) {

test/e2e/support/retry-policy.test.ts

@@ -183,6 +183,41 @@ describe("bounded E2E operation retry policy", () => {
     expect(JSON.stringify(caught?.evidence)).not.toContain(secret);
   });
 
+  it("preserves exhaustion when a bounded retry ends in cleanup failure", async () => {
+    const run = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("temporary transport failure"))
+      .mockRejectedValueOnce(new Error("cleanup failed"));
+    let caught: RetryPolicyError | undefined;
+    try {
+      await runBoundedRetry({
+        operation: "sandbox.cleanup",
+        owner: "nemoclaw",
+        idempotence: "idempotent",
+        maxAttempts: 2,
+        run,
+        classify: (_value, error) => ({
+          outcome: "failed",
+          failureClass:
+            error instanceof Error && error.message === "temporary transport failure"
+              ? "transient-external"
+              : "cleanup",
+        }),
+      });
+    } catch (error) {
+      caught = error as RetryPolicyError;
+    }
+
+    expect(caught).toBeInstanceOf(RetryPolicyError);
+    expect(caught?.evidence).toMatchObject({
+      outcome: "exhausted",
+      attempts: [
+        { failureClass: "transient-external", retryScheduled: true },
+        { failureClass: "cleanup", retryScheduled: false },
+      ],
+    });
+  });
+
   it("rejects malformed policy bounds before running", async () => {
     const run = vi.fn();
     await expect(