@oneuptime/common 11.5.3 → 11.5.5

package/Tests/Server/Services/AIRunCodeFixClaim.test.ts

@@ -0,0 +1,401 @@
+import AIRunService from "../../../Server/Services/AIRunService";
+import AIRun from "../../../Models/DatabaseModels/AIRun";
+import AIRunStatus from "../../../Types/AI/AIRunStatus";
+import CodeFixTaskType from "../../../Types/AI/CodeFixTaskType";
+import CodeFixTaskContext from "../../../Types/AI/CodeFixTaskContext";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * The code-fix claim behind POST /ai-agent-task/get-pending-task: the
+ * oldest Queued CodeFix run is claimed with the same status+attemptCount
+ * guarded CAS the investigation queue uses, so concurrent agent workers can
+ * never receive the same run. These tests mock findOneBy /
+ * attemptStatusTransition (the AIInvestigationQueue test idiom) and
+ * lock in the claim invariants.
+ */
+
+function fakeQueuedRun(data?: {
+  exceptionId?: ObjectID | null;
+  attemptCount?: number;
+  codeFixTaskType?: CodeFixTaskType;
+  incidentId?: ObjectID;
+  alertId?: ObjectID;
+  taskContext?: CodeFixTaskContext;
+}): AIRun {
+  return {
+    id: ObjectID.generate(),
+    projectId: ObjectID.generate(),
+    triggeredByTelemetryExceptionId:
+      data?.exceptionId === null
+        ? undefined
+        : data?.exceptionId || ObjectID.generate(),
+    triggeredByIncidentId: data?.incidentId,
+    triggeredByAlertId: data?.alertId,
+    attemptCount: data?.attemptCount || 0,
+    codeFixTaskType: data?.codeFixTaskType,
+    taskContext: data?.taskContext,
+  } as unknown as AIRun;
+}
+
+describe("AIRunService.claimNextQueuedCodeFixRun", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("returns null when no queued code-fix run exists — no CAS attempted", async () => {
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(null);
+    const transition: jest.SpyInstance = jest.spyOn(
+      AIRunService,
+      "attemptStatusTransition",
+    );
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBeNull();
+    expect(transition).not.toHaveBeenCalled();
+  });
+
+  test("a won claim transitions Queued -> Running with heartbeat, agent id and attemptCount+1", async () => {
+    const run: AIRun = fakeQueuedRun();
+    const aiAgentId: ObjectID = ObjectID.generate();
+
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
+    const transition: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId,
+    });
+
+    expect(claimed).toBe(run);
+    expect(transition).toHaveBeenCalledTimes(1);
+    expect(transition).toHaveBeenCalledWith(
+      expect.objectContaining({
+        aiRunId: run.id,
+        fromStatus: AIRunStatus.Queued,
+        // Guards against stale snapshots re-claiming or re-numbering.
+        expectedAttemptCount: 0,
+        set: expect.objectContaining({
+          status: AIRunStatus.Running,
+          attemptCount: 1,
+          startedAt: expect.any(Date),
+          lastHeartbeatAt: expect.any(Date),
+          /*
+           * The transition path bypasses column transformers, so the agent
+           * id must be its pre-transformed string form.
+           */
+          aiAgentId: aiAgentId.toString(),
+        }),
+      }),
+    );
+  });
+
+  test("a lost claim retries with the next candidate instead of returning it", async () => {
+    const lostRun: AIRun = fakeQueuedRun();
+    const wonRun: AIRun = fakeQueuedRun();
+
+    jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValueOnce(lostRun)
+      .mockResolvedValueOnce(wonRun);
+    jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValueOnce(0) // another agent won lostRun
+      .mockResolvedValueOnce(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(wonRun);
+  });
+
+  test("an exception-based run without a triggering exception is finalized as Error and skipped", async () => {
+    const brokenRun: AIRun = fakeQueuedRun({ exceptionId: null });
+    const goodRun: AIRun = fakeQueuedRun();
+
+    jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValueOnce(brokenRun)
+      .mockResolvedValueOnce(goodRun);
+    const transition: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(goodRun);
+    // Claim broken -> Error broken -> claim good.
+    expect(transition).toHaveBeenCalledTimes(3);
+    expect(transition).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        aiRunId: brokenRun.id,
+        fromStatus: AIRunStatus.Running,
+        set: expect.objectContaining({
+          status: AIRunStatus.Error,
+        }),
+      }),
+    );
+  });
+
+  /*
+   * The executability guard is recipe-dependent: ImproveInstrumentation
+   * runs are enqueued by the inconclusive-investigation trigger with an
+   * incident/alert subject and NO telemetry exception — the claim must
+   * hand them to the worker, not Error them for lacking an exception.
+   */
+  test("an ImproveInstrumentation run without an exception but with an incident subject is claimed, not errored", async () => {
+    const run: AIRun = fakeQueuedRun({
+      exceptionId: null,
+      codeFixTaskType: CodeFixTaskType.ImproveInstrumentation,
+      incidentId: ObjectID.generate(),
+    });
+
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
+    const transition: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(run);
+    expect(claimed?.codeFixTaskType).toBe(
+      CodeFixTaskType.ImproveInstrumentation,
+    );
+    // Exactly the claim CAS — no Error transition.
+    expect(transition).toHaveBeenCalledTimes(1);
+  });
+
+  test("an ImproveInstrumentation run with an alert subject is claimed too", async () => {
+    const run: AIRun = fakeQueuedRun({
+      exceptionId: null,
+      codeFixTaskType: CodeFixTaskType.ImproveInstrumentation,
+      alertId: ObjectID.generate(),
+    });
+
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
+    jest.spyOn(AIRunService, "attemptStatusTransition").mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(run);
+  });
+
+  /*
+   * FixFromIncident is the second incident/alert-subject recipe: enqueued
+   * by the user from the investigation panel, no telemetry exception — the
+   * same recipe grouping as ImproveInstrumentation in the guard.
+   */
+  test("a FixFromIncident run without an exception but with an incident subject is claimed, not errored", async () => {
+    const run: AIRun = fakeQueuedRun({
+      exceptionId: null,
+      codeFixTaskType: CodeFixTaskType.FixFromIncident,
+      incidentId: ObjectID.generate(),
+    });
+
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
+    const transition: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(run);
+    expect(claimed?.codeFixTaskType).toBe(CodeFixTaskType.FixFromIncident);
+    // Exactly the claim CAS — no Error transition.
+    expect(transition).toHaveBeenCalledTimes(1);
+  });
+
+  test("a FixFromIncident run with an alert subject is claimed too", async () => {
+    const run: AIRun = fakeQueuedRun({
+      exceptionId: null,
+      codeFixTaskType: CodeFixTaskType.FixFromIncident,
+      alertId: ObjectID.generate(),
+    });
+
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
+    jest.spyOn(AIRunService, "attemptStatusTransition").mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(run);
+  });
+
+  test("a FixFromIncident run with NO subject at all is finalized as Error and skipped", async () => {
+    const brokenRun: AIRun = fakeQueuedRun({
+      exceptionId: null,
+      codeFixTaskType: CodeFixTaskType.FixFromIncident,
+    });
+    const goodRun: AIRun = fakeQueuedRun();
+
+    jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValueOnce(brokenRun)
+      .mockResolvedValueOnce(goodRun);
+    const transition: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(goodRun);
+    expect(transition).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        aiRunId: brokenRun.id,
+        fromStatus: AIRunStatus.Running,
+        set: expect.objectContaining({
+          status: AIRunStatus.Error,
+          errorMessage: expect.stringContaining("incident or alert subject"),
+        }),
+      }),
+    );
+  });
+
+  /*
+   * FixPerformance is the third context kind: no exception AND no
+   * incident/alert subject — its trace evidence lives in taskContext. The
+   * guard must accept it when taskContext carries a traceId and Error it
+   * when the evidence is missing.
+   */
+  test("a FixPerformance run with trace evidence in taskContext is claimed — no exception, no subject", async () => {
+    const run: AIRun = fakeQueuedRun({
+      exceptionId: null,
+      codeFixTaskType: CodeFixTaskType.FixPerformance,
+      taskContext: {
+        traceId: "abc123trace",
+        performanceFindings: [],
+      },
+    });
+
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
+    const transition: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(run);
+    expect(claimed?.codeFixTaskType).toBe(CodeFixTaskType.FixPerformance);
+    // Exactly the claim CAS — no Error transition.
+    expect(transition).toHaveBeenCalledTimes(1);
+  });
+
+  test("a FixPerformance run with NO trace evidence is finalized as Error and skipped", async () => {
+    const brokenRun: AIRun = fakeQueuedRun({
+      exceptionId: null,
+      codeFixTaskType: CodeFixTaskType.FixPerformance,
+    });
+    const goodRun: AIRun = fakeQueuedRun();
+
+    jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValueOnce(brokenRun)
+      .mockResolvedValueOnce(goodRun);
+    const transition: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(goodRun);
+    expect(transition).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        aiRunId: brokenRun.id,
+        fromStatus: AIRunStatus.Running,
+        set: expect.objectContaining({
+          status: AIRunStatus.Error,
+          errorMessage: expect.stringContaining("trace evidence"),
+        }),
+      }),
+    );
+  });
+
+  test("a FixPerformance run carrying an incident id but no taskContext is still errored — the guard groups by context kind, not by whatever record happens to exist", async () => {
+    const brokenRun: AIRun = fakeQueuedRun({
+      exceptionId: null,
+      codeFixTaskType: CodeFixTaskType.FixPerformance,
+      incidentId: ObjectID.generate(),
+    });
+    const goodRun: AIRun = fakeQueuedRun();
+
+    jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValueOnce(brokenRun)
+      .mockResolvedValueOnce(goodRun);
+    const transition: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(goodRun);
+    expect(transition).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        aiRunId: brokenRun.id,
+        set: expect.objectContaining({
+          status: AIRunStatus.Error,
+          errorMessage: expect.stringContaining("trace evidence"),
+        }),
+      }),
+    );
+  });
+
+  test("an ImproveInstrumentation run with NO subject at all is finalized as Error and skipped", async () => {
+    const brokenRun: AIRun = fakeQueuedRun({
+      exceptionId: null,
+      codeFixTaskType: CodeFixTaskType.ImproveInstrumentation,
+    });
+    const goodRun: AIRun = fakeQueuedRun();
+
+    jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValueOnce(brokenRun)
+      .mockResolvedValueOnce(goodRun);
+    const transition: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+
+    const claimed: AIRun | null = await AIRunService.claimNextQueuedCodeFixRun({
+      aiAgentId: ObjectID.generate(),
+    });
+
+    expect(claimed).toBe(goodRun);
+    expect(transition).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        aiRunId: brokenRun.id,
+        fromStatus: AIRunStatus.Running,
+        set: expect.objectContaining({
+          status: AIRunStatus.Error,
+          errorMessage: expect.stringContaining("incident or alert subject"),
+        }),
+      }),
+    );
+  });
+});

package/Tests/Server/Services/AIRunHumanVerdict.test.ts

@@ -0,0 +1,161 @@
+import AIRunService from "../../../Server/Services/AIRunService";
+import AIRun from "../../../Models/DatabaseModels/AIRun";
+import AIRunType from "../../../Types/AI/AIRunType";
+import AIRunStatus from "../../../Types/AI/AIRunStatus";
+import AIRunHumanVerdict from "../../../Types/AI/AIRunHumanVerdict";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * Human verdict capture (Phase 2 measurement layer): the one-click
+ * Confirm / Reject on the investigation panel lands here, via
+ * POST /ai-investigation/verdict → applyHumanVerdictToLatestInvestigation.
+ * Contract under test: the verdict applies to the LATEST COMPLETED
+ * investigation for the subject, rejects when none exists, stores
+ * verdict + at + byUserId, and overwriting is allowed (a user may change
+ * their mind — there is deliberately no "already has a verdict" guard).
+ */
+
+const incidentId: ObjectID = ObjectID.generate();
+const alertId: ObjectID = ObjectID.generate();
+const userId: ObjectID = ObjectID.generate();
+
+function fakeRun(): AIRun {
+  return { id: ObjectID.generate() } as unknown as AIRun;
+}
+
+describe("AIRunService.applyHumanVerdictToLatestInvestigation", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("a subjectless call is rejected before any query", async () => {
+    const findOneBy: jest.SpyInstance = jest.spyOn(AIRunService, "findOneBy");
+
+    await expect(
+      AIRunService.applyHumanVerdictToLatestInvestigation({
+        verdict: AIRunHumanVerdict.Confirmed,
+        verdictByUserId: userId,
+      }),
+    ).rejects.toThrow(BadDataException);
+
+    expect(findOneBy).not.toHaveBeenCalled();
+  });
+
+  test("no completed investigation → reject with a clear message, nothing written", async () => {
+    const findOneBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValue(null);
+    const updateOneById: jest.SpyInstance = jest.spyOn(
+      AIRunService,
+      "updateOneById",
+    );
+
+    await expect(
+      AIRunService.applyHumanVerdictToLatestInvestigation({
+        incidentId,
+        verdict: AIRunHumanVerdict.Confirmed,
+        verdictByUserId: userId,
+      }),
+    ).rejects.toThrow(/No completed AI investigation/);
+
+    // The lookup must target the LATEST COMPLETED investigation.
+    expect(findOneBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        query: expect.objectContaining({
+          runType: AIRunType.Investigation,
+          status: AIRunStatus.Completed,
+          triggeredByIncidentId: incidentId,
+        }),
+        sort: expect.objectContaining({ createdAt: SortOrder.Descending }),
+      }),
+    );
+    expect(updateOneById).not.toHaveBeenCalled();
+  });
+
+  test("happy path (incident): stores verdict + at + byUserId on the run and returns {runId, verdict}", async () => {
+    const run: AIRun = fakeRun();
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
+    const updateOneById: jest.SpyInstance = jest
+      .spyOn(AIRunService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    const result: { runId: ObjectID; verdict: AIRunHumanVerdict } =
+      await AIRunService.applyHumanVerdictToLatestInvestigation({
+        incidentId,
+        verdict: AIRunHumanVerdict.Confirmed,
+        verdictByUserId: userId,
+      });
+
+    expect(result.runId).toBe(run.id);
+    expect(result.verdict).toBe(AIRunHumanVerdict.Confirmed);
+
+    expect(updateOneById).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: run.id,
+        data: expect.objectContaining({
+          humanVerdict: AIRunHumanVerdict.Confirmed,
+          humanVerdictAt: expect.any(Date),
+          humanVerdictByUserId: userId,
+        }),
+        props: expect.objectContaining({ isRoot: true }),
+      }),
+    );
+  });
+
+  test("happy path (alert): the lookup keys on triggeredByAlertId", async () => {
+    const run: AIRun = fakeRun();
+    const findOneBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "findOneBy")
+      .mockResolvedValue(run);
+    jest
+      .spyOn(AIRunService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    await AIRunService.applyHumanVerdictToLatestInvestigation({
+      alertId,
+      verdict: AIRunHumanVerdict.Rejected,
+      verdictByUserId: userId,
+    });
+
+    expect(findOneBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        query: expect.objectContaining({
+          runType: AIRunType.Investigation,
+          status: AIRunStatus.Completed,
+          triggeredByAlertId: alertId,
+        }),
+      }),
+    );
+  });
+
+  test("idempotent overwrite: a run that already carries a verdict is simply re-written", async () => {
+    // The service deliberately does NOT guard on an existing verdict.
+    const run: AIRun = {
+      id: ObjectID.generate(),
+      humanVerdict: AIRunHumanVerdict.Confirmed,
+    } as unknown as AIRun;
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
+    const updateOneById: jest.SpyInstance = jest
+      .spyOn(AIRunService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    const result: { runId: ObjectID; verdict: AIRunHumanVerdict } =
+      await AIRunService.applyHumanVerdictToLatestInvestigation({
+        incidentId,
+        verdict: AIRunHumanVerdict.Rejected,
+        verdictByUserId: userId,
+      });
+
+    expect(result.verdict).toBe(AIRunHumanVerdict.Rejected);
+    expect(updateOneById).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          humanVerdict: AIRunHumanVerdict.Rejected,
+        }),
+      }),
+    );
+  });
+});

package/Tests/Server/Services/AIServiceDailyBudget.test.ts

@@ -1,8 +1,17 @@
 import AIService, {
   AUTONOMOUS_AI_FEATURES,
   AutonomousBudgetStatus,
+  LEGACY_AUTONOMOUS_AI_FEATURES,
+  AI_ALERT_INVESTIGATION_FEATURE,
+  AI_CODE_FIX_FEATURE,
+  AI_CONFIDENCE_CLASSIFICATION_FEATURE,
+  AI_INCIDENT_INVESTIGATION_FEATURE,
+  AI_INSIGHT_TRIAGE_FEATURE,
+  AI_INVESTIGATION_GRADING_FEATURE,
+  RUNBOOK_AI_STEP_FEATURE,
+  WORKFLOW_AI_FEATURE,
 } from "../../../Server/Services/AIService";
-import SentinelInvestigationQueue from "../../../Server/Utils/AI/Sentinel/InvestigationQueue";
+import AIInvestigationQueue from "../../../Server/Utils/AI/SRE/InvestigationQueue";
 import LlmLogService from "../../../Server/Services/LlmLogService";
 import ProjectService from "../../../Server/Services/ProjectService";
 import AIRunService from "../../../Server/Services/AIRunService";
@@ -32,6 +41,87 @@ function fakeProject(limit: number | undefined): Project {
   } as unknown as Project;
 }
 
+/*
+ * The budget is enforced by matching PERSISTED LlmLog.feature strings against
+ * AUTONOMOUS_AI_FEATURES, so these labels are data, not display text. Changing
+ * one silently rewrites a project's usage history for the current UTC day:
+ * older rows stop matching, usedTokensToday collapses toward zero, and an
+ * already-exhausted project gets a fresh full budget. These tests pin the
+ * exact wire values and the legacy aliases so no rename can do that quietly.
+ */
+describe("AUTONOMOUS_AI_FEATURES persisted labels", () => {
+  test("each label has its exact persisted value", () => {
+    expect(AI_INCIDENT_INVESTIGATION_FEATURE).toBe("AI Incident Investigation");
+    expect(AI_ALERT_INVESTIGATION_FEATURE).toBe("AI Alert Investigation");
+    expect(AI_INVESTIGATION_GRADING_FEATURE).toBe("AI Investigation Grading");
+    expect(AI_CONFIDENCE_CLASSIFICATION_FEATURE).toBe(
+      "AI Confidence Classification",
+    );
+    expect(AI_CODE_FIX_FEATURE).toBe("AI Code Fix");
+    expect(AI_INSIGHT_TRIAGE_FEATURE).toBe("AI Insight Triage");
+    expect(RUNBOOK_AI_STEP_FEATURE).toBe("Runbook AI Step");
+    expect(WORKFLOW_AI_FEATURE).toBe("Workflow AI");
+  });
+
+  test("the budget match-list covers every autonomous feature", () => {
+    for (const feature of [
+      AI_INCIDENT_INVESTIGATION_FEATURE,
+      AI_ALERT_INVESTIGATION_FEATURE,
+      AI_INVESTIGATION_GRADING_FEATURE,
+      AI_CONFIDENCE_CLASSIFICATION_FEATURE,
+      AI_CODE_FIX_FEATURE,
+      AI_INSIGHT_TRIAGE_FEATURE,
+      RUNBOOK_AI_STEP_FEATURE,
+      WORKFLOW_AI_FEATURE,
+    ]) {
+      expect(AUTONOMOUS_AI_FEATURES).toContain(feature);
+    }
+  });
+
+  /*
+   * The budget hole this guards: the six labels below were persisted by the
+   * pre-rename code. Dropping them from the match-list stops LlmLog rows that
+   * ALREADY carry them from counting — during the deploy window (old and new
+   * pods write different labels into the same UTC day) and for any row the
+   * backfill migration missed. A future cleanup must fail here and go read the
+   * retention argument in AIService before deleting them.
+   */
+  test("the six legacy Sentinel labels are still counted by the budget", () => {
+    expect(LEGACY_AUTONOMOUS_AI_FEATURES).toEqual([
+      "Sentinel Incident Investigation",
+      "Sentinel Alert Investigation",
+      "Sentinel Investigation Grading",
+      "Sentinel Confidence Classification",
+      "Sentinel Code Fix",
+      "Sentinel Insight Triage",
+    ]);
+
+    for (const legacyFeature of LEGACY_AUTONOMOUS_AI_FEATURES) {
+      expect(AUTONOMOUS_AI_FEATURES).toContain(legacyFeature);
+    }
+  });
+
+  /*
+   * Nothing but the constants and the legacy aliases may reach the list — a
+   * raw literal here is how a writer and the budget silently drift apart.
+   */
+  test("the match-list is exactly the current labels plus the legacy aliases", () => {
+    expect([...AUTONOMOUS_AI_FEATURES].sort()).toEqual(
+      [
+        AI_INCIDENT_INVESTIGATION_FEATURE,
+        AI_ALERT_INVESTIGATION_FEATURE,
+        AI_INVESTIGATION_GRADING_FEATURE,
+        AI_CONFIDENCE_CLASSIFICATION_FEATURE,
+        AI_CODE_FIX_FEATURE,
+        AI_INSIGHT_TRIAGE_FEATURE,
+        RUNBOOK_AI_STEP_FEATURE,
+        WORKFLOW_AI_FEATURE,
+        ...LEGACY_AUTONOMOUS_AI_FEATURES,
+      ].sort(),
+    );
+  });
+});
+
 describe("AIService.getAutonomousDailyBudgetStatus", () => {
   const projectId: ObjectID = ObjectID.generate();
 
@@ -107,7 +197,7 @@ describe("AIService.getAutonomousDailyBudgetStatus", () => {
   });
 });
 
-describe("SentinelInvestigationQueue budget skip", () => {
+describe("AIInvestigationQueue budget skip", () => {
   afterEach(() => {
     jest.restoreAllMocks();
   });
@@ -120,7 +210,7 @@ describe("SentinelInvestigationQueue budget skip", () => {
     });
     const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
 
-    await SentinelInvestigationQueue.enqueue({
+    await AIInvestigationQueue.enqueue({
       projectId: ObjectID.generate(),
       subjectAlertId: ObjectID.generate(),
     });
@@ -134,7 +224,7 @@ describe("SentinelInvestigationQueue budget skip", () => {
       .mockRejectedValue(new Error("db down"));
     const create: jest.SpyInstance = jest.spyOn(AIRunService, "create");
 
-    await SentinelInvestigationQueue.enqueue({
+    await AIInvestigationQueue.enqueue({
       projectId: ObjectID.generate(),
       subjectAlertId: ObjectID.generate(),
     });
@@ -161,7 +251,7 @@ describe("SentinelInvestigationQueue budget skip", () => {
       "attemptStatusTransition",
     );
 
-    await SentinelInvestigationQueue.processRun({
+    await AIInvestigationQueue.processRun({
       id: ObjectID.generate(),
       projectId: ObjectID.generate(),
       attemptCount: 0,