@oneuptime/common 11.5.4 → 11.5.6

package/Tests/Server/Utils/AI/{SentinelAlertGating.test.ts → AIAlertGating.test.ts}

@@ -1,7 +1,7 @@
-import SentinelAlertInvestigationRunner, {
+import AIAlertInvestigationRunner, {
   AlertGateDecision,
-} from "../../../../Server/Utils/AI/Sentinel/AlertInvestigationRunner";
-import SentinelInvestigationQueue from "../../../../Server/Utils/AI/Sentinel/InvestigationQueue";
+} from "../../../../Server/Utils/AI/SRE/AlertInvestigationRunner";
+import AIInvestigationQueue from "../../../../Server/Utils/AI/SRE/InvestigationQueue";
 import AlertService from "../../../../Server/Services/AlertService";
 import AlertSeverityService from "../../../../Server/Services/AlertSeverityService";
 import ProjectService from "../../../../Server/Services/ProjectService";
@@ -59,7 +59,7 @@ function fakeSeverities(orders: Array<number>): Array<AlertSeverity> {
   });
 }
 
-describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
+describe("AIAlertInvestigationRunner.shouldInvestigateAlert", () => {
   const alertId: ObjectID = ObjectID.generate();
   const projectId: ObjectID = ObjectID.generate();
 
@@ -98,7 +98,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -118,7 +118,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -134,7 +134,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -149,7 +149,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -167,7 +167,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -182,7 +182,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -201,7 +201,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -226,7 +226,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -247,7 +247,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -267,7 +267,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -280,7 +280,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
     mockGates({ alert: null });
 
     const decision: AlertGateDecision =
-      await SentinelAlertInvestigationRunner.shouldInvestigateAlert({
+      await AIAlertInvestigationRunner.shouldInvestigateAlert({
         alertId,
         projectId,
       });
@@ -289,7 +289,7 @@ describe("SentinelAlertInvestigationRunner.shouldInvestigateAlert", () => {
   });
 });
 
-describe("SentinelInvestigationQueue concurrency cap", () => {
+describe("AIInvestigationQueue concurrency cap", () => {
   beforeEach(() => {
     // No per-project override => the default cap of 3 applies.
     jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
@@ -308,7 +308,7 @@ describe("SentinelInvestigationQueue concurrency cap", () => {
       "attemptStatusTransition",
     );
 
-    await SentinelInvestigationQueue.processRun({
+    await AIInvestigationQueue.processRun({
       id: ObjectID.generate(),
       projectId: ObjectID.generate(),
       attemptCount: 0,
@@ -325,7 +325,7 @@ describe("SentinelInvestigationQueue concurrency cap", () => {
       "attemptStatusTransition",
     );
 
-    await SentinelInvestigationQueue.processRun({
+    await AIInvestigationQueue.processRun({
       id: ObjectID.generate(),
       projectId: ObjectID.generate(),
       attemptCount: 0,
@@ -348,7 +348,7 @@ describe("SentinelInvestigationQueue concurrency cap", () => {
       "attemptStatusTransition",
     );
 
-    await SentinelInvestigationQueue.processRun({
+    await AIInvestigationQueue.processRun({
       id: ObjectID.generate(),
       projectId: ObjectID.generate(),
       attemptCount: 0,

package/Tests/Server/Utils/AI/AIConfidenceSignal.test.ts

@@ -0,0 +1,362 @@
+import AIConfidenceSignal, {
+  CONFIDENCE_CLASSIFICATION_FEATURE,
+  ConfidenceSignal,
+  EvidenceInput,
+} from "../../../../Server/Utils/AI/SRE/ConfidenceSignal";
+import AIService, {
+  AILogResponse,
+  AUTONOMOUS_AI_FEATURES,
+} from "../../../../Server/Services/AIService";
+import { AIChatCitation } from "../../../../Types/AI/AIChatTypes";
+import ObjectID from "../../../../Types/ObjectID";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * The G6 structured confidence signal: no control-flow decision may derive
+ * from free-form model prose. Under test: the deterministic evidence floor
+ * (zero server-minted evidence → inconclusive, always, no LLM spent), the
+ * word-bounded CONFIDENT/INCONCLUSIVE token parse, the PER-CONSUMER fail
+ * directions (ping fails louder; instrumentation-PR creation fails toward
+ * doing nothing), and computeConfidenceSignal's never-throws contract.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const aiRunId: ObjectID = ObjectID.generate();
+
+function fakeCitation(rowCount: number): AIChatCitation {
+  return {
+    id: `C${rowCount}`,
+    toolName: "search_logs",
+    label: "Logs",
+    queryArguments: {},
+    rowCount,
+  } as AIChatCitation;
+}
+
+function evidence(data: Partial<EvidenceInput>): EvidenceInput {
+  return {
+    citationCount: 0,
+    dataBearingToolCallCount: 0,
+    anyToolReturnedData: false,
+    ...data,
+  };
+}
+
+function fakeLlmResponse(content: string): AILogResponse {
+  return { content } as unknown as AILogResponse;
+}
+
+describe("AIConfidenceSignal.evidenceFromCitations", () => {
+  test("no citations → zero evidence", () => {
+    expect(AIConfidenceSignal.evidenceFromCitations([])).toEqual({
+      citationCount: 0,
+      dataBearingToolCallCount: 0,
+      anyToolReturnedData: false,
+    });
+  });
+
+  test("counts data-bearing citations separately from row-less ones", () => {
+    expect(
+      AIConfidenceSignal.evidenceFromCitations([
+        fakeCitation(0),
+        fakeCitation(3),
+        fakeCitation(12),
+      ]),
+    ).toEqual({
+      citationCount: 3,
+      dataBearingToolCallCount: 2,
+      anyToolReturnedData: true,
+    });
+  });
+
+  test("citations whose every result was empty carry no data", () => {
+    expect(
+      AIConfidenceSignal.evidenceFromCitations([
+        fakeCitation(0),
+        fakeCitation(0),
+      ]),
+    ).toEqual({
+      citationCount: 2,
+      dataBearingToolCallCount: 0,
+      anyToolReturnedData: false,
+    });
+  });
+});
+
+describe("AIConfidenceSignal.hasVerifiableEvidence (deterministic floor)", () => {
+  test("zero citations AND zero data-bearing tool calls → no evidence, always", () => {
+    expect(AIConfidenceSignal.hasVerifiableEvidence(evidence({}))).toBe(false);
+  });
+
+  test("a single minted citation passes the floor (rowCount 0 is proof of absence — still server-verified evidence)", () => {
+    expect(
+      AIConfidenceSignal.hasVerifiableEvidence(evidence({ citationCount: 1 })),
+    ).toBe(true);
+  });
+
+  test("a data-bearing tool call passes the floor even without a citation count (defensive OR)", () => {
+    expect(
+      AIConfidenceSignal.hasVerifiableEvidence(
+        evidence({ dataBearingToolCallCount: 1 }),
+      ),
+    ).toBe(true);
+    expect(
+      AIConfidenceSignal.hasVerifiableEvidence(
+        evidence({ anyToolReturnedData: true }),
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("AIConfidenceSignal.parseClassificationToken", () => {
+  test("exact single tokens parse (case-insensitively, whitespace-tolerant)", () => {
+    expect(AIConfidenceSignal.parseClassificationToken("CONFIDENT")).toBe(true);
+    expect(AIConfidenceSignal.parseClassificationToken(" inconclusive\n")).toBe(
+      false,
+    );
+    expect(AIConfidenceSignal.parseClassificationToken("confident")).toBe(true);
+  });
+
+  test("a token embedded in editorializing prose still parses", () => {
+    expect(
+      AIConfidenceSignal.parseClassificationToken("The analysis is CONFIDENT."),
+    ).toBe(true);
+    expect(
+      AIConfidenceSignal.parseClassificationToken(
+        "I would call this INCONCLUSIVE, the evidence is thin.",
+      ),
+    ).toBe(false);
+  });
+
+  test("a token embedded inside a larger word does not parse (word boundaries)", () => {
+    expect(
+      AIConfidenceSignal.parseClassificationToken("CONFIDENTLY"),
+    ).toBeNull();
+    expect(
+      AIConfidenceSignal.parseClassificationToken("inconclusively"),
+    ).toBeNull();
+  });
+
+  test("both tokens → null (ambiguous)", () => {
+    expect(
+      AIConfidenceSignal.parseClassificationToken(
+        "Either CONFIDENT or INCONCLUSIVE, hard to say.",
+      ),
+    ).toBeNull();
+  });
+
+  test("no token / empty / null → null", () => {
+    expect(
+      AIConfidenceSignal.parseClassificationToken("I cannot judge this."),
+    ).toBeNull();
+    expect(AIConfidenceSignal.parseClassificationToken("")).toBeNull();
+    expect(AIConfidenceSignal.parseClassificationToken(null)).toBeNull();
+    expect(AIConfidenceSignal.parseClassificationToken(undefined)).toBeNull();
+  });
+});
+
+describe("per-consumer fail directions", () => {
+  const floorInconclusive: ConfidenceSignal = {
+    confident: false,
+    source: "deterministic-floor",
+  };
+  const classifiedConfident: ConfidenceSignal = {
+    confident: true,
+    source: "classification",
+  };
+  const classifiedInconclusive: ConfidenceSignal = {
+    confident: false,
+    source: "classification",
+  };
+  const classificationFailed: ConfidenceSignal = {
+    confident: false,
+    source: "classification-failed",
+  };
+
+  test("workspace ping: confident classifications ping; verified-inconclusive stays quiet", () => {
+    expect(
+      AIConfidenceSignal.shouldSendWorkspaceNotification(classifiedConfident),
+    ).toBe(true);
+    expect(
+      AIConfidenceSignal.shouldSendWorkspaceNotification(
+        classifiedInconclusive,
+      ),
+    ).toBe(false);
+    expect(
+      AIConfidenceSignal.shouldSendWorkspaceNotification(floorInconclusive),
+    ).toBe(false);
+  });
+
+  test("workspace ping fails LOUDER: classification-failed → ping sends", () => {
+    expect(
+      AIConfidenceSignal.shouldSendWorkspaceNotification(classificationFailed),
+    ).toBe(true);
+  });
+
+  test("instrumentation PR: only a POSITIVE inconclusive verdict enqueues", () => {
+    expect(
+      AIConfidenceSignal.shouldEnqueueInstrumentationTask(floorInconclusive),
+    ).toBe(true);
+    expect(
+      AIConfidenceSignal.shouldEnqueueInstrumentationTask(
+        classifiedInconclusive,
+      ),
+    ).toBe(true);
+    expect(
+      AIConfidenceSignal.shouldEnqueueInstrumentationTask(classifiedConfident),
+    ).toBe(false);
+  });
+
+  test("instrumentation PR fails toward DOING NOTHING: classification-failed → no PR", () => {
+    expect(
+      AIConfidenceSignal.shouldEnqueueInstrumentationTask(classificationFailed),
+    ).toBe(false);
+  });
+});
+
+describe("AIConfidenceSignal.computeConfidenceSignal", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("the deterministic floor short-circuits: zero evidence → inconclusive, NO LLM call — prose cannot fake evidence that was never minted", async () => {
+    const executeWithLogging: jest.SpyInstance = jest.spyOn(
+      AIService,
+      "executeWithLogging",
+    );
+
+    const signal: ConfidenceSignal =
+      await AIConfidenceSignal.computeConfidenceSignal({
+        projectId,
+        aiRunId,
+        analysisMarkdown:
+          "**Most likely root cause** — definitely the database, trust me.",
+        evidence: evidence({}),
+      });
+
+    expect(signal).toEqual({
+      confident: false,
+      source: "deterministic-floor",
+    });
+    expect(executeWithLogging).not.toHaveBeenCalled();
+  });
+
+  test("floor passes + CONFIDENT token → one budgeted, preview-less, temperature-0 call", async () => {
+    const executeWithLogging: jest.SpyInstance = jest
+      .spyOn(AIService, "executeWithLogging")
+      .mockResolvedValue(fakeLlmResponse("CONFIDENT"));
+
+    const signal: ConfidenceSignal =
+      await AIConfidenceSignal.computeConfidenceSignal({
+        projectId,
+        aiRunId,
+        analysisMarkdown: "The connection pool ran dry [C1].",
+        evidence: evidence({
+          citationCount: 2,
+          dataBearingToolCallCount: 1,
+          anyToolReturnedData: true,
+        }),
+      });
+
+    expect(signal).toEqual({ confident: true, source: "classification" });
+
+    expect(executeWithLogging).toHaveBeenCalledTimes(1);
+    expect(executeWithLogging).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectId,
+        aiRunId,
+        // Budget coverage: must be an AUTONOMOUS_AI_FEATURES member.
+        feature: CONFIDENCE_CLASSIFICATION_FEATURE,
+        // The verdict drives control flow — no prompt previews in LlmLog.
+        storeContentPreviews: false,
+        temperature: 0,
+        maxTokens: 20,
+      }),
+    );
+  });
+
+  test("INCONCLUSIVE token → classified inconclusive", async () => {
+    jest
+      .spyOn(AIService, "executeWithLogging")
+      .mockResolvedValue(fakeLlmResponse("INCONCLUSIVE"));
+
+    const signal: ConfidenceSignal =
+      await AIConfidenceSignal.computeConfidenceSignal({
+        projectId,
+        aiRunId,
+        analysisMarkdown: "Nothing anomalous found in any signal [C1].",
+        evidence: evidence({ citationCount: 1 }),
+      });
+
+    expect(signal).toEqual({ confident: false, source: "classification" });
+  });
+
+  test("unparseable response (neither or both tokens) → classification-failed", async () => {
+    const executeWithLogging: jest.SpyInstance = jest
+      .spyOn(AIService, "executeWithLogging")
+      .mockResolvedValue(fakeLlmResponse("CONFIDENT... no wait, INCONCLUSIVE"));
+
+    expect(
+      await AIConfidenceSignal.computeConfidenceSignal({
+        projectId,
+        aiRunId,
+        analysisMarkdown: "Analysis.",
+        evidence: evidence({ citationCount: 1 }),
+      }),
+    ).toEqual({ confident: false, source: "classification-failed" });
+
+    executeWithLogging.mockResolvedValue(fakeLlmResponse("I cannot say."));
+
+    expect(
+      await AIConfidenceSignal.computeConfidenceSignal({
+        projectId,
+        aiRunId,
+        analysisMarkdown: "Analysis.",
+        evidence: evidence({ citationCount: 1 }),
+      }),
+    ).toEqual({ confident: false, source: "classification-failed" });
+  });
+
+  test("an LLM failure (provider down, daily budget rejection) → classification-failed, never a throw", async () => {
+    jest
+      .spyOn(AIService, "executeWithLogging")
+      .mockRejectedValue(new Error("Daily AI token budget exhausted"));
+
+    await expect(
+      AIConfidenceSignal.computeConfidenceSignal({
+        projectId,
+        aiRunId,
+        analysisMarkdown: "Analysis.",
+        evidence: evidence({ citationCount: 1 }),
+      }),
+    ).resolves.toEqual({
+      confident: false,
+      source: "classification-failed",
+    });
+  });
+
+  test("the analysis is truncated to 8000 chars before it reaches the classifier", async () => {
+    const executeWithLogging: jest.SpyInstance = jest
+      .spyOn(AIService, "executeWithLogging")
+      .mockResolvedValue(fakeLlmResponse("CONFIDENT"));
+
+    const analysisMarkdown: string = "H".repeat(8000) + "TAIL_MARKER";
+
+    await AIConfidenceSignal.computeConfidenceSignal({
+      projectId,
+      aiRunId,
+      analysisMarkdown,
+      evidence: evidence({ citationCount: 1 }),
+    });
+
+    const userMessage: { content: string } =
+      executeWithLogging.mock.calls[0]![0].messages[1];
+
+    expect(userMessage.content).toContain("H".repeat(8000));
+    expect(userMessage.content).not.toContain("TAIL_MARKER");
+  });
+
+  test("the feature is covered by the G4 daily autonomous budget", () => {
+    expect(AUTONOMOUS_AI_FEATURES).toContain(CONFIDENCE_CLASSIFICATION_FEATURE);
+  });
+});

package/Tests/Server/Utils/AI/{SentinelInvestigationQueue.test.ts → AIInvestigationQueue.test.ts}

@@ -1,8 +1,8 @@
-import SentinelInvestigationQueue, {
+import AIInvestigationQueue, {
   MAX_INVESTIGATION_ATTEMPTS,
-} from "../../../../Server/Utils/AI/Sentinel/InvestigationQueue";
-import SentinelIncidentInvestigationRunner from "../../../../Server/Utils/AI/Sentinel/IncidentInvestigationRunner";
-import SentinelAlertInvestigationRunner from "../../../../Server/Utils/AI/Sentinel/AlertInvestigationRunner";
+} from "../../../../Server/Utils/AI/SRE/InvestigationQueue";
+import AIIncidentInvestigationRunner from "../../../../Server/Utils/AI/SRE/IncidentInvestigationRunner";
+import AIAlertInvestigationRunner from "../../../../Server/Utils/AI/SRE/AlertInvestigationRunner";
 import AIRunService from "../../../../Server/Services/AIRunService";
 import AIService from "../../../../Server/Services/AIService";
 import ProjectService from "../../../../Server/Services/ProjectService";
@@ -39,7 +39,7 @@ function mockBudgetOk(): void {
   });
 }
 
-describe("SentinelInvestigationQueue", () => {
+describe("AIInvestigationQueue", () => {
   beforeEach(() => {
     mockBudgetOk();
     // No per-project cap override => default of 3.
@@ -65,10 +65,10 @@ describe("SentinelInvestigationQueue", () => {
       .spyOn(AIRunService, "create")
       .mockResolvedValue({ id: createdId } as unknown as AIRun);
     const processRun: jest.SpyInstance = jest
-      .spyOn(SentinelInvestigationQueue, "processRun")
+      .spyOn(AIInvestigationQueue, "processRun")
       .mockResolvedValue(undefined);
 
-    await SentinelInvestigationQueue.enqueue({
+    await AIInvestigationQueue.enqueue({
       projectId,
       subjectIncidentId: incidentId,
     });
@@ -97,11 +97,11 @@ describe("SentinelInvestigationQueue", () => {
   test("a lost claim never executes the investigation", async () => {
     jest.spyOn(AIRunService, "attemptStatusTransition").mockResolvedValue(0);
     const execute: jest.SpyInstance = jest.spyOn(
-      SentinelIncidentInvestigationRunner,
+      AIIncidentInvestigationRunner,
       "executeInvestigation",
     );
 
-    await SentinelInvestigationQueue.processRun({
+    await AIInvestigationQueue.processRun({
       id: ObjectID.generate(),
       projectId: ObjectID.generate(),
       attemptCount: 0,
@@ -118,10 +118,10 @@ describe("SentinelInvestigationQueue", () => {
       .spyOn(AIRunService, "attemptStatusTransition")
       .mockResolvedValue(1);
     const execute: jest.SpyInstance = jest
-      .spyOn(SentinelIncidentInvestigationRunner, "executeInvestigation")
+      .spyOn(AIIncidentInvestigationRunner, "executeInvestigation")
       .mockResolvedValue(undefined);
 
-    await SentinelInvestigationQueue.processRun({
+    await AIInvestigationQueue.processRun({
       id: runId,
       projectId: ObjectID.generate(),
       attemptCount: 0,
@@ -153,10 +153,10 @@ describe("SentinelInvestigationQueue", () => {
     const alertId: ObjectID = ObjectID.generate();
     jest.spyOn(AIRunService, "attemptStatusTransition").mockResolvedValue(1);
     const execute: jest.SpyInstance = jest
-      .spyOn(SentinelAlertInvestigationRunner, "executeInvestigation")
+      .spyOn(AIAlertInvestigationRunner, "executeInvestigation")
       .mockResolvedValue(undefined);
 
-    await SentinelInvestigationQueue.processRun({
+    await AIInvestigationQueue.processRun({
       id: ObjectID.generate(),
       projectId: ObjectID.generate(),
       attemptCount: 0,
@@ -174,7 +174,7 @@ describe("SentinelInvestigationQueue", () => {
       .spyOn(AIRunService, "attemptStatusTransition")
       .mockResolvedValue(1);
 
-    await SentinelInvestigationQueue.failOrRequeue({
+    await AIInvestigationQueue.failOrRequeue({
       aiRunId: runId,
       attemptCount: 1,
       errorMessage: "LLM provider timed out",
@@ -197,7 +197,7 @@ describe("SentinelInvestigationQueue", () => {
       .spyOn(AIRunService, "attemptStatusTransition")
       .mockResolvedValue(1);
 
-    await SentinelInvestigationQueue.failOrRequeue({
+    await AIInvestigationQueue.failOrRequeue({
       aiRunId: ObjectID.generate(),
       attemptCount: MAX_INVESTIGATION_ATTEMPTS,
       errorMessage: "LLM provider timed out",
@@ -218,7 +218,7 @@ describe("SentinelInvestigationQueue", () => {
       .spyOn(AIRunService, "attemptStatusTransition")
       .mockResolvedValue(1);
 
-    await SentinelInvestigationQueue.failOrRequeue({
+    await AIInvestigationQueue.failOrRequeue({
       aiRunId: ObjectID.generate(),
       attemptCount: 1,
       errorMessage: "No LLM provider configured for this project.",
@@ -239,7 +239,7 @@ describe("SentinelInvestigationQueue", () => {
     jest.spyOn(AIRunService, "attemptStatusTransition").mockResolvedValue(1);
 
     const outcome: "requeued" | "stale" =
-      await SentinelInvestigationQueue.requeueOrMarkStale({
+      await AIInvestigationQueue.requeueOrMarkStale({
         id: ObjectID.generate(),
         attemptCount: 1,
       });
@@ -253,7 +253,7 @@ describe("SentinelInvestigationQueue", () => {
       .mockResolvedValue(1);
 
     const outcome: "requeued" | "stale" =
-      await SentinelInvestigationQueue.requeueOrMarkStale({
+      await AIInvestigationQueue.requeueOrMarkStale({
         id: ObjectID.generate(),
         attemptCount: MAX_INVESTIGATION_ATTEMPTS,
       });
@@ -279,7 +279,7 @@ describe("SentinelInvestigationQueue", () => {
       .spyOn(AIRunService, "attemptStatusTransition")
       .mockResolvedValue(1);
 
-    await SentinelInvestigationQueue.processQueuedRuns();
+    await AIInvestigationQueue.processQueuedRuns();
 
     expect(findBy).toHaveBeenCalledTimes(2);
     expect(update).toHaveBeenCalledWith(