@oneuptime/common 12.0.3 → 12.0.5

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

@@ -4,6 +4,7 @@ import FixRunBudget, {
 } from "../../../../Server/Utils/AI/CodeFix/FixRunBudget";
 import ProjectService from "../../../../Server/Services/ProjectService";
 import AIRunService from "../../../../Server/Services/AIRunService";
+import QueryHelper from "../../../../Server/Types/Database/QueryHelper";
 import Project from "../../../../Models/DatabaseModels/Project";
 import AIRunType from "../../../../Types/AI/AIRunType";
 import BadDataException from "../../../../Types/Exception/BadDataException";
@@ -12,11 +13,11 @@ import PositiveNumber from "../../../../Types/PositiveNumber";
 import { describe, expect, test, afterEach } from "@jest/globals";
 
 /*
- * The per-project daily fix-run budget (G11 guardrail): every CodeFix
- * AIRun counts against Project.aiDailyFixTaskLimit per UTC day. Unlike the
- * token budget, an UNSET limit is NOT unlimited — fix runs open pull
+ * The per-project daily fix-run budget (G11 guardrail): incident, alert and
+ * subjectless CodeFix AIRuns each count only against their own lane. Unlike
+ * the token budget, an UNSET limit is NOT unlimited — fix runs open pull
  * requests on customer repositories, so the default cap applies. 0 pauses
- * fix tasks entirely (the same kill-switch semantics as the token budget).
+ * that lane entirely (the same kill-switch semantics as the token budget).
  */
 
 const projectId: ObjectID = ObjectID.generate();
@@ -92,24 +93,37 @@ describe("FixRunBudget.evaluate (pure decision)", () => {
 });
 
 describe("FixRunBudget.describeRejection", () => {
-  test("paused rejection names the setting and the 0 value", () => {
+  test("paused incident rejection names the incident setting and destination", () => {
     const message: string = FixRunBudget.describeRejection(
       FixRunBudget.evaluate({ configuredLimit: 0, runsToday: 0 }),
+      { incidentId: ObjectID.generate() },
     );
 
-    expect(message).toMatch(/Daily AI Fix Task Limit/);
+    expect(message).toMatch(/Daily Incident AI Fix Task Limit/);
+    expect(message).toMatch(/Incidents > Settings > AI/);
     expect(message).toMatch(/0/);
   });
 
-  test("over-budget rejection names the counts, the setting and the default", () => {
+  test("over-budget alert rejection names the alert setting and destination", () => {
     const message: string = FixRunBudget.describeRejection(
       FixRunBudget.evaluate({ configuredLimit: 10, runsToday: 10 }),
+      { alertId: ObjectID.generate() },
     );
 
     expect(message).toMatch(/10 of 10/);
-    expect(message).toMatch(/Daily AI Fix Task Limit/);
+    expect(message).toMatch(/Daily Alert AI Fix Task Limit/);
+    expect(message).toMatch(/Alerts > Settings > AI/);
     expect(message).toMatch(new RegExp(String(DEFAULT_DAILY_FIX_RUN_LIMIT)));
   });
+
+  test("subjectless rejection points to the always-visible AI Guardrails page", () => {
+    const message: string = FixRunBudget.describeRejection(
+      FixRunBudget.evaluate({ configuredLimit: 0, runsToday: 0 }),
+    );
+
+    expect(message).toMatch(/Daily Other AI Fix Task Limit/);
+    expect(message).toMatch(/Project Settings > AI > AI Guardrails/);
+  });
 });
 
 describe("FixRunBudget.getBudgetStatus (IO wiring)", () => {
@@ -117,12 +131,46 @@ describe("FixRunBudget.getBudgetStatus (IO wiring)", () => {
     jest.restoreAllMocks();
   });
 
-  test("counts the project's CodeFix runs created since UTC midnight", async () => {
-    jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
-      id: projectId,
-      aiDailyFixTaskLimit: 10,
-    } as unknown as Project);
+  function mockSubjectOperators(): {
+    isNull: Record<string, string>;
+    notNull: Record<string, string>;
+  } {
+    const isNull: Record<string, string> = { operator: "is-null" };
+    const notNull: Record<string, string> = { operator: "not-null" };
+
+    jest.spyOn(QueryHelper, "isNull").mockReturnValue(isNull);
+    jest.spyOn(QueryHelper, "notNull").mockReturnValue(notNull);
 
+    return { isNull, notNull };
+  }
+
+  test("rejects a run carrying both subject types before reading project settings", async () => {
+    const findProject: jest.SpyInstance = jest.spyOn(
+      ProjectService,
+      "findOneById",
+    );
+
+    await expect(
+      FixRunBudget.getBudgetStatus(projectId, {
+        incidentId: ObjectID.generate(),
+        alertId: ObjectID.generate(),
+      }),
+    ).rejects.toThrow(/both an incident and an alert/);
+
+    expect(findProject).not.toHaveBeenCalled();
+  });
+
+  test("subjectless callers retain the fallback limit and count only subjectless CodeFix runs", async () => {
+    const operators: ReturnType<typeof mockSubjectOperators> =
+      mockSubjectOperators();
+    const findProject: jest.SpyInstance = jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue({
+        id: projectId,
+        aiDailyFixTaskLimit: 10,
+        incidentAiDailyFixTaskLimit: 1,
+        alertAiDailyFixTaskLimit: 2,
+      } as unknown as Project);
     const countBy: jest.SpyInstance = jest
       .spyOn(AIRunService, "countBy")
       .mockResolvedValue(new PositiveNumber(4));
@@ -136,44 +184,180 @@ describe("FixRunBudget.getBudgetStatus (IO wiring)", () => {
       paused: false,
       runsToday: 4,
     });
+    expect(findProject).toHaveBeenCalledWith(
+      expect.objectContaining({ select: { aiDailyFixTaskLimit: true } }),
+    );
+
+    const query: Record<string, unknown> = (
+      countBy.mock.calls[0]![0] as { query: Record<string, unknown> }
+    ).query;
+    expect(query["projectId"]).toBe(projectId);
+    expect(query["runType"]).toBe(AIRunType.CodeFix);
+    expect(query["triggeredByIncidentId"]).toBe(operators.isNull);
+    expect(query["triggeredByAlertId"]).toBe(operators.isNull);
+    // createdAt >= UTC midnight rides in a QueryHelper find operator.
+    expect(query["createdAt"]).toBeDefined();
+  });
+
+  test("an explicitly empty subject from SubjectCodeFixRun also stays in the subjectless lane", async () => {
+    const operators: ReturnType<typeof mockSubjectOperators> =
+      mockSubjectOperators();
+    const findProject: jest.SpyInstance = jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue({
+        id: projectId,
+        aiDailyFixTaskLimit: 3,
+        incidentAiDailyFixTaskLimit: 0,
+        alertAiDailyFixTaskLimit: 0,
+      } as unknown as Project);
+    const countBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "countBy")
+      .mockResolvedValue(new PositiveNumber(2));
+
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { incidentId: undefined, alertId: undefined },
+    );
+
+    expect(decision.limit).toBe(3);
+    expect(decision.allowed).toBe(true);
+    expect(findProject).toHaveBeenCalledWith(
+      expect.objectContaining({ select: { aiDailyFixTaskLimit: true } }),
+    );
+
+    const query: Record<string, unknown> = (
+      countBy.mock.calls[0]![0] as { query: Record<string, unknown> }
+    ).query;
+    expect(query["triggeredByIncidentId"]).toBe(operators.isNull);
+    expect(query["triggeredByAlertId"]).toBe(operators.isNull);
+  });
+
+  test("incident callers select the incident limit and count only incident CodeFix runs", async () => {
+    const operators: ReturnType<typeof mockSubjectOperators> =
+      mockSubjectOperators();
+    const findProject: jest.SpyInstance = jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue({
+        id: projectId,
+        aiDailyFixTaskLimit: 99,
+        incidentAiDailyFixTaskLimit: 5,
+        alertAiDailyFixTaskLimit: 1,
+      } as unknown as Project);
+    const countBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "countBy")
+      .mockResolvedValue(new PositiveNumber(4));
+
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { incidentId: ObjectID.generate() },
+    );
 
-    expect(countBy).toHaveBeenCalledWith(
+    expect(decision).toEqual({
+      allowed: true,
+      limit: 5,
+      paused: false,
+      runsToday: 4,
+    });
+    expect(findProject).toHaveBeenCalledWith(
       expect.objectContaining({
-        query: expect.objectContaining({
-          projectId,
-          runType: AIRunType.CodeFix,
-          // createdAt >= UTC midnight rides in a QueryHelper find operator.
-          createdAt: expect.anything(),
-        }),
-        props: expect.objectContaining({ isRoot: true }),
+        select: { incidentAiDailyFixTaskLimit: true },
       }),
     );
+
+    const query: Record<string, unknown> = (
+      countBy.mock.calls[0]![0] as { query: Record<string, unknown> }
+    ).query;
+    expect(query["runType"]).toBe(AIRunType.CodeFix);
+    expect(query["triggeredByIncidentId"]).toBe(operators.notNull);
+    expect(query["triggeredByAlertId"]).toBe(operators.isNull);
   });
 
-  test("a paused project (limit 0) short-circuits without the count query", async () => {
+  test("alert callers select the alert limit and count only alert CodeFix runs", async () => {
+    const operators: ReturnType<typeof mockSubjectOperators> =
+      mockSubjectOperators();
+    const findProject: jest.SpyInstance = jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue({
+        id: projectId,
+        aiDailyFixTaskLimit: 99,
+        incidentAiDailyFixTaskLimit: 1,
+        alertAiDailyFixTaskLimit: 7,
+      } as unknown as Project);
+    const countBy: jest.SpyInstance = jest
+      .spyOn(AIRunService, "countBy")
+      .mockResolvedValue(new PositiveNumber(6));
+
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { alertId: ObjectID.generate() },
+    );
+
+    expect(decision).toEqual({
+      allowed: true,
+      limit: 7,
+      paused: false,
+      runsToday: 6,
+    });
+    expect(findProject).toHaveBeenCalledWith(
+      expect.objectContaining({ select: { alertAiDailyFixTaskLimit: true } }),
+    );
+
+    const query: Record<string, unknown> = (
+      countBy.mock.calls[0]![0] as { query: Record<string, unknown> }
+    ).query;
+    expect(query["runType"]).toBe(AIRunType.CodeFix);
+    expect(query["triggeredByIncidentId"]).toBe(operators.isNull);
+    expect(query["triggeredByAlertId"]).toBe(operators.notNull);
+  });
+
+  test("pausing the incident lane short-circuits without counting another lane", async () => {
     jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
       id: projectId,
-      aiDailyFixTaskLimit: 0,
+      aiDailyFixTaskLimit: 50,
+      incidentAiDailyFixTaskLimit: 0,
+      alertAiDailyFixTaskLimit: 50,
     } as unknown as Project);
+    const countBy: jest.SpyInstance = jest.spyOn(AIRunService, "countBy");
+
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { incidentId: ObjectID.generate() },
+    );
+
+    expect(decision.allowed).toBe(false);
+    expect(decision.paused).toBe(true);
+    expect(countBy).not.toHaveBeenCalled();
+  });
 
+  test("pausing the alert lane short-circuits without counting another lane", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
+      id: projectId,
+      aiDailyFixTaskLimit: 50,
+      incidentAiDailyFixTaskLimit: 50,
+      alertAiDailyFixTaskLimit: 0,
+    } as unknown as Project);
     const countBy: jest.SpyInstance = jest.spyOn(AIRunService, "countBy");
 
-    const decision: FixRunBudgetDecision =
-      await FixRunBudget.getBudgetStatus(projectId);
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { alertId: ObjectID.generate() },
+    );
 
     expect(decision.allowed).toBe(false);
     expect(decision.paused).toBe(true);
     expect(countBy).not.toHaveBeenCalled();
   });
 
-  test("a missing project row falls back to the default cap (fail-safe, not fail-open)", async () => {
+  test("a missing project row uses the default cap in the requested lane (fail-safe, not fail-open)", async () => {
     jest.spyOn(ProjectService, "findOneById").mockResolvedValue(null);
     jest
       .spyOn(AIRunService, "countBy")
       .mockResolvedValue(new PositiveNumber(DEFAULT_DAILY_FIX_RUN_LIMIT));
 
-    const decision: FixRunBudgetDecision =
-      await FixRunBudget.getBudgetStatus(projectId);
+    const decision: FixRunBudgetDecision = await FixRunBudget.getBudgetStatus(
+      projectId,
+      { alertId: ObjectID.generate() },
+    );
 
     expect(decision.limit).toBe(DEFAULT_DAILY_FIX_RUN_LIMIT);
     expect(decision.allowed).toBe(false);
@@ -199,7 +383,7 @@ describe("FixRunBudget.assertWithinBudget", () => {
     ).resolves.toBeUndefined();
   });
 
-  test("over budget throws a BadDataException naming the setting", async () => {
+  test("over budget throws a BadDataException naming the subjectless setting", async () => {
     jest.spyOn(ProjectService, "findOneById").mockResolvedValue({
       id: projectId,
       aiDailyFixTaskLimit: 5,
@@ -212,7 +396,7 @@ describe("FixRunBudget.assertWithinBudget", () => {
       BadDataException,
     );
     await expect(FixRunBudget.assertWithinBudget(projectId)).rejects.toThrow(
-      /Daily AI Fix Task Limit/,
+      /Daily Other AI Fix Task Limit/,
     );
   });
 });

package/Tests/Server/Utils/AI/Insights/InvestigationQueueInsightSubject.test.ts

@@ -8,6 +8,7 @@ import AIService from "../../../../../Server/Services/AIService";
 import ProjectService from "../../../../../Server/Services/ProjectService";
 import Project from "../../../../../Models/DatabaseModels/Project";
 import AIRun from "../../../../../Models/DatabaseModels/AIRun";
+import AIRunCodeFixRecommendation from "../../../../../Types/AI/AIRunCodeFixRecommendation";
 import AIRunStatus from "../../../../../Types/AI/AIRunStatus";
 import AIRunType from "../../../../../Types/AI/AIRunType";
 import ObjectID from "../../../../../Types/ObjectID";
@@ -76,6 +77,7 @@ describe("AIInvestigationQueue — insight subject", () => {
         data: expect.objectContaining({
           status: AIRunStatus.Queued,
           triggeredByAiInsightId: insightId,
+          codeFixRecommendation: AIRunCodeFixRecommendation.NotRecommended,
         }),
         props: expect.objectContaining({ isRoot: true }),
       }),

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

@@ -1,13 +1,12 @@
 import InvestigationGrader from "../../../../Server/Utils/AI/SRE/InvestigationGrader";
+import PostedRootCause from "../../../../Server/Utils/AI/SRE/PostedRootCause";
 import AIRunService from "../../../../Server/Services/AIRunService";
 import IncidentService from "../../../../Server/Services/IncidentService";
-import IncidentFeedService from "../../../../Server/Services/IncidentFeedService";
 import AIService, {
   AILogResponse,
 } from "../../../../Server/Services/AIService";
 import AIRun from "../../../../Models/DatabaseModels/AIRun";
 import Incident from "../../../../Models/DatabaseModels/Incident";
-import IncidentFeed from "../../../../Models/DatabaseModels/IncidentFeed";
 import AIRunAutoGrade from "../../../../Types/AI/AIRunAutoGrade";
 import ObjectID from "../../../../Types/ObjectID";
 import { describe, expect, test, afterEach } from "@jest/globals";
@@ -24,19 +23,20 @@ import { describe, expect, test, afterEach } from "@jest/globals";
 
 const incidentId: ObjectID = ObjectID.generate();
 const projectId: ObjectID = ObjectID.generate();
+const runCompletedAt: Date = new Date("2026-08-07T12:00:00.000Z");
 
 function fakeRun(autoGrade?: AIRunAutoGrade): AIRun {
-  return { id: ObjectID.generate(), autoGrade } as unknown as AIRun;
+  return {
+    id: ObjectID.generate(),
+    autoGrade,
+    completedAt: runCompletedAt,
+  } as unknown as AIRun;
 }
 
 function fakeIncident(rootCause?: string | undefined): Incident {
   return { id: incidentId, rootCause } as unknown as Incident;
 }
 
-function fakeFeedItem(markdown: string): IncidentFeed {
-  return { feedInfoInMarkdown: markdown } as unknown as IncidentFeed;
-}
-
 function fakeLlmResponse(content: string): AILogResponse {
   return { content } as unknown as AILogResponse;
 }
@@ -221,11 +221,14 @@ describe("InvestigationGrader.gradeInvestigationOnResolve", () => {
   });
 
   test("no posted analysis (no RootCause feed item) → no LLM call", async () => {
-    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(fakeRun());
+    const run: AIRun = fakeRun();
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
     jest
       .spyOn(IncidentService, "findOneById")
       .mockResolvedValue(fakeIncident("db down"));
-    jest.spyOn(IncidentFeedService, "findOneBy").mockResolvedValue(null);
+    const getForInvestigation: jest.SpyInstance = jest
+      .spyOn(PostedRootCause, "getForInvestigation")
+      .mockResolvedValue(null);
     const executeWithLogging: jest.SpyInstance = jest.spyOn(
       AIService,
       "executeWithLogging",
@@ -236,9 +239,56 @@ describe("InvestigationGrader.gradeInvestigationOnResolve", () => {
       projectId,
     });
 
+    expect(getForInvestigation).toHaveBeenCalledWith({
+      incidentId,
+      aiRunId: run.id,
+      runCompletedAt,
+    });
     expect(executeWithLogging).not.toHaveBeenCalled();
   });
 
+  test("reads the report associated with the selected completed run exactly", async () => {
+    const run: AIRun = fakeRun();
+    const selectedAnalysis: string =
+      "## Selected investigation\nThe selected run found pool exhaustion.";
+    jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
+    jest
+      .spyOn(IncidentService, "findOneById")
+      .mockResolvedValue(fakeIncident("The connection pool was exhausted."));
+    const getForInvestigation: jest.SpyInstance = jest
+      .spyOn(PostedRootCause, "getForInvestigation")
+      .mockResolvedValue(selectedAnalysis);
+    const executeWithLogging: jest.SpyInstance = jest
+      .spyOn(AIService, "executeWithLogging")
+      .mockResolvedValue(fakeLlmResponse("MATCH"));
+    jest
+      .spyOn(AIRunService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    await InvestigationGrader.gradeInvestigationOnResolve({
+      incidentId,
+      projectId,
+    });
+
+    expect(getForInvestigation).toHaveBeenCalledTimes(1);
+    expect(getForInvestigation).toHaveBeenCalledWith({
+      incidentId,
+      aiRunId: run.id,
+      runCompletedAt,
+    });
+    expect(executeWithLogging).toHaveBeenCalledWith(
+      expect.objectContaining({
+        aiRunId: run.id,
+        messages: expect.arrayContaining([
+          expect.objectContaining({
+            role: "user",
+            content: expect.stringContaining(selectedAnalysis),
+          }),
+        ]),
+      }),
+    );
+  });
+
   test("happy path: one budgeted, preview-less LLM call; grade + timestamp stored on the run", async () => {
     const run: AIRun = fakeRun();
     jest.spyOn(AIRunService, "findOneBy").mockResolvedValue(run);
@@ -246,10 +296,8 @@ describe("InvestigationGrader.gradeInvestigationOnResolve", () => {
       .spyOn(IncidentService, "findOneById")
       .mockResolvedValue(fakeIncident("The connection pool was exhausted."));
     jest
-      .spyOn(IncidentFeedService, "findOneBy")
-      .mockResolvedValue(
-        fakeFeedItem("## Analysis\nThe db connection pool ran dry."),
-      );
+      .spyOn(PostedRootCause, "getForInvestigation")
+      .mockResolvedValue("## Analysis\nThe db connection pool ran dry.");
     const executeWithLogging: jest.SpyInstance = jest
       .spyOn(AIService, "executeWithLogging")
       .mockResolvedValue(fakeLlmResponse("MATCH"));
@@ -297,8 +345,8 @@ describe("InvestigationGrader.gradeInvestigationOnResolve", () => {
       .spyOn(IncidentService, "findOneById")
       .mockResolvedValue(fakeIncident("db down"));
     jest
-      .spyOn(IncidentFeedService, "findOneBy")
-      .mockResolvedValue(fakeFeedItem("Analysis text."));
+      .spyOn(PostedRootCause, "getForInvestigation")
+      .mockResolvedValue("Analysis text.");
     jest
       .spyOn(AIService, "executeWithLogging")
       .mockResolvedValue(fakeLlmResponse("Either MATCH or MISMATCH."));
@@ -321,8 +369,8 @@ describe("InvestigationGrader.gradeInvestigationOnResolve", () => {
       .spyOn(IncidentService, "findOneById")
       .mockResolvedValue(fakeIncident("db down"));
     jest
-      .spyOn(IncidentFeedService, "findOneBy")
-      .mockResolvedValue(fakeFeedItem("Analysis text."));
+      .spyOn(PostedRootCause, "getForInvestigation")
+      .mockResolvedValue("Analysis text.");
     jest
       .spyOn(AIService, "executeWithLogging")
       .mockRejectedValue(new Error("provider down"));

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

@@ -5,6 +5,7 @@ import AIService from "../../../../Server/Services/AIService";
 import ProjectService from "../../../../Server/Services/ProjectService";
 import AIRun from "../../../../Models/DatabaseModels/AIRun";
 import Project from "../../../../Models/DatabaseModels/Project";
+import AIRunCodeFixRecommendation from "../../../../Types/AI/AIRunCodeFixRecommendation";
 import AIRunStatus from "../../../../Types/AI/AIRunStatus";
 import AIRunType from "../../../../Types/AI/AIRunType";
 import ObjectID from "../../../../Types/ObjectID";
@@ -96,6 +97,7 @@ describe("AIInvestigationQueue — RemediationExecution runs", () => {
           status: AIRunStatus.Queued,
           runType: AIRunType.RemediationExecution,
           triggeredByAutoRemediationSuggestionId: SUGGESTION_ID,
+          codeFixRecommendation: AIRunCodeFixRecommendation.NotRecommended,
           // Incident linkage stays set for the dashboard.
           triggeredByIncidentId: INCIDENT_ID,
         }),
@@ -131,6 +133,7 @@ describe("AIInvestigationQueue — RemediationExecution runs", () => {
         data: expect.objectContaining({
           runType: AIRunType.RemediationPlan,
           triggeredByAutoRemediationSuggestionId: SUGGESTION_ID,
+          codeFixRecommendation: AIRunCodeFixRecommendation.NotRecommended,
         }),
       }),
     );