@oneuptime/common 11.7.4 → 12.0.0

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

@@ -0,0 +1,294 @@
+import FixFromIncidentTaskTrigger, {
+  AutoFixTaskGateDecision,
+} from "../../../../Server/Utils/AI/SRE/FixFromIncidentTaskTrigger";
+import SubjectCodeFixRun from "../../../../Server/Utils/AI/SRE/SubjectCodeFixRun";
+import FixRunBudget from "../../../../Server/Utils/AI/CodeFix/FixRunBudget";
+import ProjectService from "../../../../Server/Services/ProjectService";
+import Project from "../../../../Models/DatabaseModels/Project";
+import AIRun from "../../../../Models/DatabaseModels/AIRun";
+import CodeFixTaskType from "../../../../Types/AI/CodeFixTaskType";
+import ObjectID from "../../../../Types/ObjectID";
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
+
+/*
+ * The AUTOMATIC form of the FixFromIncident trigger: a CONFIDENT
+ * investigation (per the structured G6 signal) enqueues a fix-PR CodeFix
+ * run with no human click — but ONLY for projects that explicitly opted in
+ * (Project.enableAutomaticCodeFixes, default FALSE — G11 posture), only
+ * when a GitHub-App repo exists to open the PR against, at most one
+ * non-terminal run per subject, and inside the daily fix-run budget. It
+ * runs inside the investigation's postAnalysis, so it must NEVER throw,
+ * and the run stays system-authored (no userId). Unlike its
+ * human-triggered sibling (createFixTaskFromInvestigation, tested in
+ * Tests/Server/Services/FixFromIncidentTaskTrigger.test.ts), every failed
+ * gate is a quiet skip, never a thrown message.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const incidentId: ObjectID = ObjectID.generate();
+const alertId: ObjectID = ObjectID.generate();
+
+function fakeProject(data?: {
+  enableAi?: boolean;
+  enableAutomaticCodeFixes?: boolean;
+}): Project {
+  return {
+    id: projectId,
+    enableAi: data?.enableAi ?? true,
+    enableAutomaticCodeFixes: data?.enableAutomaticCodeFixes ?? true,
+  } as unknown as Project;
+}
+
+function fakeRun(): AIRun {
+  return { id: ObjectID.generate() } as unknown as AIRun;
+}
+
+describe("FixFromIncidentTaskTrigger.shouldAutoEnqueueFixTask", () => {
+  test("does not enqueue when the project is missing", () => {
+    const decision: AutoFixTaskGateDecision =
+      FixFromIncidentTaskTrigger.shouldAutoEnqueueFixTask({
+        project: null,
+        hasConnectedRepository: true,
+        existingRun: null,
+      });
+
+    expect(decision.enqueue).toBe(false);
+    expect(decision.reason).toMatch(/not found/);
+  });
+
+  test("does not enqueue when AI is disabled for the project", () => {
+    const decision: AutoFixTaskGateDecision =
+      FixFromIncidentTaskTrigger.shouldAutoEnqueueFixTask({
+        project: fakeProject({ enableAi: false }),
+        hasConnectedRepository: true,
+        existingRun: null,
+      });
+
+    expect(decision.enqueue).toBe(false);
+    expect(decision.reason).toMatch(/disabled/);
+  });
+
+  test("opt-in is strict: an unset flag (legacy row) never enqueues — default is FALSE", () => {
+    const project: Project = {
+      id: projectId,
+      enableAi: true,
+      // enableAutomaticCodeFixes deliberately absent.
+    } as unknown as Project;
+
+    const decision: AutoFixTaskGateDecision =
+      FixFromIncidentTaskTrigger.shouldAutoEnqueueFixTask({
+        project,
+        hasConnectedRepository: true,
+        existingRun: null,
+      });
+
+    expect(decision.enqueue).toBe(false);
+    expect(decision.reason).toMatch(/not opted in/);
+  });
+
+  test("an explicit false flag never enqueues", () => {
+    const decision: AutoFixTaskGateDecision =
+      FixFromIncidentTaskTrigger.shouldAutoEnqueueFixTask({
+        project: fakeProject({ enableAutomaticCodeFixes: false }),
+        hasConnectedRepository: true,
+        existingRun: null,
+      });
+
+    expect(decision.enqueue).toBe(false);
+    expect(decision.reason).toMatch(/not opted in/);
+  });
+
+  test("does not enqueue without a GitHub-App-connected repository", () => {
+    const decision: AutoFixTaskGateDecision =
+      FixFromIncidentTaskTrigger.shouldAutoEnqueueFixTask({
+        project: fakeProject(),
+        hasConnectedRepository: false,
+        existingRun: null,
+      });
+
+    expect(decision.enqueue).toBe(false);
+    expect(decision.reason).toMatch(/repository/);
+  });
+
+  test("dedupe: an existing non-terminal run for the subject blocks a second one", () => {
+    const decision: AutoFixTaskGateDecision =
+      FixFromIncidentTaskTrigger.shouldAutoEnqueueFixTask({
+        project: fakeProject(),
+        hasConnectedRepository: true,
+        existingRun: fakeRun(),
+      });
+
+    expect(decision.enqueue).toBe(false);
+    expect(decision.reason).toMatch(/already exists/);
+  });
+
+  test("enqueues when opted in, a repository exists, and no run is live for the subject", () => {
+    const decision: AutoFixTaskGateDecision =
+      FixFromIncidentTaskTrigger.shouldAutoEnqueueFixTask({
+        project: fakeProject(),
+        hasConnectedRepository: true,
+        existingRun: null,
+      });
+
+    expect(decision.enqueue).toBe(true);
+    expect(decision.reason).toMatch(/passed/);
+  });
+});
+
+describe("FixFromIncidentTaskTrigger.autoEnqueueFromConfidentInvestigation", () => {
+  let getBudgetStatus: jest.SpyInstance;
+  let hasRepository: jest.SpyInstance;
+  let findNonTerminalRun: jest.SpyInstance;
+  let enqueue: jest.SpyInstance;
+
+  beforeEach(() => {
+    /*
+     * The daily fix-run budget defaults to allowed; its own decision matrix
+     * lives in FixRunBudget.test.ts.
+     */
+    getBudgetStatus = jest
+      .spyOn(FixRunBudget, "getBudgetStatus")
+      .mockResolvedValue({
+        allowed: true,
+        limit: 25,
+        paused: false,
+        runsToday: 0,
+      });
+    hasRepository = jest
+      .spyOn(SubjectCodeFixRun, "hasGitHubAppConnectedRepository")
+      .mockResolvedValue(true);
+    findNonTerminalRun = jest
+      .spyOn(SubjectCodeFixRun, "findNonTerminalRunForSubject")
+      .mockResolvedValue(null);
+    enqueue = jest
+      .spyOn(SubjectCodeFixRun, "enqueueSubjectCodeFixRun")
+      .mockResolvedValue(fakeRun());
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("a subjectless call is an immediate no-op: no project read, no gate IO", async () => {
+    const findProject: jest.SpyInstance = jest.spyOn(
+      ProjectService,
+      "findOneById",
+    );
+
+    await FixFromIncidentTaskTrigger.autoEnqueueFromConfidentInvestigation({
+      projectId,
+    });
+
+    expect(findProject).not.toHaveBeenCalled();
+    expect(getBudgetStatus).not.toHaveBeenCalled();
+    expect(hasRepository).not.toHaveBeenCalled();
+    expect(findNonTerminalRun).not.toHaveBeenCalled();
+    expect(enqueue).not.toHaveBeenCalled();
+  });
+
+  test("a not-opted-in project (default) skips cheaply: BEFORE the budget, repo and dedupe queries", async () => {
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(fakeProject({ enableAutomaticCodeFixes: false }));
+
+    await FixFromIncidentTaskTrigger.autoEnqueueFromConfidentInvestigation({
+      projectId,
+      incidentId,
+    });
+
+    expect(getBudgetStatus).not.toHaveBeenCalled();
+    expect(hasRepository).not.toHaveBeenCalled();
+    expect(findNonTerminalRun).not.toHaveBeenCalled();
+    expect(enqueue).not.toHaveBeenCalled();
+  });
+
+  test("over the daily fix-run budget: a quiet SKIP — nothing enqueued, nothing thrown into the investigation", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+    getBudgetStatus.mockResolvedValue({
+      allowed: false,
+      limit: 25,
+      paused: false,
+      runsToday: 25,
+    });
+
+    await expect(
+      FixFromIncidentTaskTrigger.autoEnqueueFromConfidentInvestigation({
+        projectId,
+        incidentId,
+      }),
+    ).resolves.toBeUndefined();
+
+    // Skipped before the repo/dedupe queries, and no run was enqueued.
+    expect(hasRepository).not.toHaveBeenCalled();
+    expect(enqueue).not.toHaveBeenCalled();
+  });
+
+  test("dedupe: a live FixFromIncident run for the same subject blocks the automatic enqueue", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+    findNonTerminalRun.mockResolvedValue(fakeRun());
+
+    await FixFromIncidentTaskTrigger.autoEnqueueFromConfidentInvestigation({
+      projectId,
+      incidentId,
+    });
+
+    // The dedupe guard queries per (subject, FixFromIncident).
+    expect(findNonTerminalRun).toHaveBeenCalledWith(
+      expect.objectContaining({
+        taskType: CodeFixTaskType.FixFromIncident,
+        incidentId,
+      }),
+    );
+    expect(enqueue).not.toHaveBeenCalled();
+  });
+
+  test("happy path (incident): enqueues a FixFromIncident run for the incident with NO user attribution", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+
+    await FixFromIncidentTaskTrigger.autoEnqueueFromConfidentInvestigation({
+      projectId,
+      incidentId,
+    });
+
+    expect(enqueue).toHaveBeenCalledTimes(1);
+    expect(enqueue).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectId,
+        taskType: CodeFixTaskType.FixFromIncident,
+        incidentId,
+      }),
+    );
+
+    // System-authored: the automatic trigger must never attribute a user.
+    expect(enqueue.mock.calls[0]![0]).not.toHaveProperty("userId");
+  });
+
+  test("happy path (alert): the enqueue carries the alert subject", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+
+    await FixFromIncidentTaskTrigger.autoEnqueueFromConfidentInvestigation({
+      projectId,
+      alertId,
+    });
+
+    expect(enqueue).toHaveBeenCalledWith(
+      expect.objectContaining({
+        taskType: CodeFixTaskType.FixFromIncident,
+        alertId,
+      }),
+    );
+    expect(enqueue.mock.calls[0]![0]).not.toHaveProperty("userId");
+  });
+
+  test("never throws — a failed enqueue must not fail the investigation's postAnalysis", async () => {
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(fakeProject());
+    enqueue.mockRejectedValue(new Error("database is down"));
+
+    await expect(
+      FixFromIncidentTaskTrigger.autoEnqueueFromConfidentInvestigation({
+        projectId,
+        incidentId,
+      }),
+    ).resolves.toBeUndefined();
+  });
+});

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

@@ -100,7 +100,7 @@ describe("InsightTriageRunner.executeTriage", () => {
       .mockRejectedValue(new Error("db down"));
     const failOrRequeue: jest.SpyInstance = jest
       .spyOn(AIInvestigationQueue, "failOrRequeue")
-      .mockResolvedValue(undefined);
+      .mockResolvedValue("requeued");
     const executeRun: jest.SpyInstance = jest.spyOn(
       AIInvestigationEngine,
       "executeRun",
@@ -127,7 +127,7 @@ describe("InsightTriageRunner.executeTriage", () => {
     jest.spyOn(AIInsightService, "findOneById").mockResolvedValue(null);
     const failOrRequeue: jest.SpyInstance = jest
       .spyOn(AIInvestigationQueue, "failOrRequeue")
-      .mockResolvedValue(undefined);
+      .mockResolvedValue("requeued");
 
     await InsightTriageRunner.executeTriage({
       aiRunId,

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

@@ -9,6 +9,7 @@ import ProjectService from "../../../../../Server/Services/ProjectService";
 import Project from "../../../../../Models/DatabaseModels/Project";
 import AIRun from "../../../../../Models/DatabaseModels/AIRun";
 import AIRunStatus from "../../../../../Types/AI/AIRunStatus";
+import AIRunType from "../../../../../Types/AI/AIRunType";
 import ObjectID from "../../../../../Types/ObjectID";
 import PositiveNumber from "../../../../../Types/PositiveNumber";
 import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
@@ -179,6 +180,11 @@ describe("AIInvestigationQueue — lane priority (triage never starves RCA)", ()
   function mockRunningCounts(counts: {
     total: number;
     triage: number;
+    /*
+     * Running remediation runs (RemediationPlan + RemediationExecution) —
+     * the other background-lane kind.
+     */
+    plans?: number;
   }): jest.SpyInstance {
     return jest
       .spyOn(AIRunService, "countBy")
@@ -192,9 +198,26 @@ describe("AIInvestigationQueue — lane priority (triage never starves RCA)", ()
         const isTriageLaneQuery: boolean =
           query["triggeredByAiInsightId"] !== undefined;
 
-        return Promise.resolve(
-          new PositiveNumber(isTriageLaneQuery ? counts.triage : counts.total),
-        );
+        /*
+         * Both the global and the remediation-lane counts filter runType
+         * with QueryHelper.any(...), so they are told apart by what is IN
+         * the list: only the global one counts Investigations.
+         */
+        const runTypeFilter: string = JSON.stringify(query["runType"] ?? null);
+
+        const isPlanLaneQuery: boolean =
+          runTypeFilter.includes(AIRunType.RemediationPlan) &&
+          !runTypeFilter.includes(AIRunType.Investigation);
+
+        if (isTriageLaneQuery) {
+          return Promise.resolve(new PositiveNumber(counts.triage));
+        }
+
+        if (isPlanLaneQuery) {
+          return Promise.resolve(new PositiveNumber(counts.plans || 0));
+        }
+
+        return Promise.resolve(new PositiveNumber(counts.total));
       });
   }
 
@@ -261,6 +284,27 @@ describe("AIInvestigationQueue — lane priority (triage never starves RCA)", ()
     expect(executeTriage).not.toHaveBeenCalled();
   });
 
+  test("remediation plans share the background sub-cap: triage + plans together at cap - reserved leave a plan run Queued", async () => {
+    mockCap(3);
+    // 1 triage + 1 plan running = cap(3) - RESERVED(1): background lane full.
+    mockRunningCounts({ total: 2, triage: 1, plans: 1 });
+    const claim: jest.SpyInstance = jest.spyOn(
+      AIRunService,
+      "attemptStatusTransition",
+    );
+
+    await AIInvestigationQueue.processRun({
+      id: ObjectID.generate(),
+      projectId,
+      attemptCount: 0,
+      runType: AIRunType.RemediationPlan,
+      triggeredByAutoRemediationSuggestionId: ObjectID.generate(),
+    });
+
+    // Left Queued — the reserved RCA slot stays reachable.
+    expect(claim).not.toHaveBeenCalled();
+  });
+
   test("triage still runs while under the lane sub-cap — the sub-cap throttles, it does not disable", async () => {
     mockCap(3);
     mockRunningCounts({ total: 1, triage: 1 });

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

@@ -0,0 +1,233 @@
+import AIInvestigationQueue from "../../../../Server/Utils/AI/SRE/InvestigationQueue";
+import RemediationExecutionRunner from "../../../../Server/Utils/AI/Remediation/RemediationExecutionRunner";
+import AIRunService from "../../../../Server/Services/AIRunService";
+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 AIRunStatus from "../../../../Types/AI/AIRunStatus";
+import AIRunType from "../../../../Types/AI/AIRunType";
+import ObjectID from "../../../../Types/ObjectID";
+import PositiveNumber from "../../../../Types/PositiveNumber";
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * Contract under test — how the durable investigation queue carries
+ * RemediationExecution runs (AI-composed commands, Phase 3):
+ *
+ * - enqueue with a suggestion subject records the run as the requested
+ *   remediationRunType (RemediationExecution), and still defaults to
+ *   RemediationPlan when no remediationRunType is given (back-compat with
+ *   aiSelectsRunbook callers);
+ * - a claimed RemediationExecution run dispatches to
+ *   RemediationExecutionRunner.executeRemediation with the run/suggestion
+ *   linkage and the claimed attempt number — runType routing comes before
+ *   the incident/alert subject columns, which remain set for dashboard
+ *   linkage;
+ * - a RemediationExecution run without a suggestion subject can never
+ *   execute — it finalizes as Error;
+ * - RemediationExecution runs count in the BACKGROUND lane: when the
+ *   background sub-cap is full the run stays Queued (no claim, no
+ *   dispatch) for the poller / TTL to deal with.
+ */
+
+const RUN_ID: ObjectID = new ObjectID("aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa");
+const PROJECT_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+const INCIDENT_ID: ObjectID = new ObjectID(
+  "cccccccc-cccc-4ccc-8ccc-cccccccccccc",
+);
+const SUGGESTION_ID: ObjectID = new ObjectID(
+  "77777777-7777-4777-8777-777777777777",
+);
+
+function mockBudgetOk(): void {
+  jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+    exhausted: false,
+    limitInTokens: null,
+    usedTokensToday: 0,
+  });
+}
+
+function flushDetachedKick(): Promise<unknown> {
+  // The inline kick is detached; give the microtask a beat.
+  return new Promise((resolve: (value: unknown) => void) => {
+    setTimeout(resolve, 0);
+  });
+}
+
+describe("AIInvestigationQueue — RemediationExecution runs", () => {
+  beforeEach(() => {
+    mockBudgetOk();
+    // No per-project cap override => default of 3.
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue({ id: PROJECT_ID } as unknown as Project);
+    // Nothing running (both the global cap and the background lane pass).
+    jest
+      .spyOn(AIRunService, "countBy")
+      .mockResolvedValue(new PositiveNumber(0));
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("enqueue records a RemediationExecution run when the caller asks for one", async () => {
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue({ id: RUN_ID } as unknown as AIRun);
+    const processRun: jest.SpyInstance = jest
+      .spyOn(AIInvestigationQueue, "processRun")
+      .mockResolvedValue(undefined);
+
+    const aiRunId: ObjectID | null = await AIInvestigationQueue.enqueue({
+      projectId: PROJECT_ID,
+      subjectIncidentId: INCIDENT_ID,
+      subjectAutoRemediationSuggestionId: SUGGESTION_ID,
+      remediationRunType: AIRunType.RemediationExecution,
+    });
+
+    expect(aiRunId).toEqual(RUN_ID);
+    expect(create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          status: AIRunStatus.Queued,
+          runType: AIRunType.RemediationExecution,
+          triggeredByAutoRemediationSuggestionId: SUGGESTION_ID,
+          // Incident linkage stays set for the dashboard.
+          triggeredByIncidentId: INCIDENT_ID,
+        }),
+        props: expect.objectContaining({ isRoot: true }),
+      }),
+    );
+
+    await flushDetachedKick();
+    expect(processRun).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: RUN_ID,
+        attemptCount: 0,
+        runType: AIRunType.RemediationExecution,
+        triggeredByAutoRemediationSuggestionId: SUGGESTION_ID,
+      }),
+    );
+  });
+
+  test("enqueue defaults a suggestion-subject run to RemediationPlan when no remediationRunType is given", async () => {
+    const create: jest.SpyInstance = jest
+      .spyOn(AIRunService, "create")
+      .mockResolvedValue({ id: RUN_ID } as unknown as AIRun);
+    jest.spyOn(AIInvestigationQueue, "processRun").mockResolvedValue(undefined);
+
+    await AIInvestigationQueue.enqueue({
+      projectId: PROJECT_ID,
+      subjectIncidentId: INCIDENT_ID,
+      subjectAutoRemediationSuggestionId: SUGGESTION_ID,
+    });
+
+    expect(create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          runType: AIRunType.RemediationPlan,
+          triggeredByAutoRemediationSuggestionId: SUGGESTION_ID,
+        }),
+      }),
+    );
+  });
+
+  test("a claimed RemediationExecution run dispatches to the execution runner", async () => {
+    const claim: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+    const execute: jest.SpyInstance = jest
+      .spyOn(RemediationExecutionRunner, "executeRemediation")
+      .mockResolvedValue(undefined);
+
+    await AIInvestigationQueue.processRun({
+      id: RUN_ID,
+      projectId: PROJECT_ID,
+      attemptCount: 0,
+      runType: AIRunType.RemediationExecution,
+      // Subject columns set for linkage must NOT reroute to the RCA runner.
+      triggeredByIncidentId: INCIDENT_ID,
+      triggeredByAutoRemediationSuggestionId: SUGGESTION_ID,
+    });
+
+    expect(claim).toHaveBeenCalledWith(
+      expect.objectContaining({
+        aiRunId: RUN_ID,
+        fromStatus: AIRunStatus.Queued,
+        expectedAttemptCount: 0,
+        set: expect.objectContaining({
+          status: AIRunStatus.Running,
+          attemptCount: 1,
+        }),
+      }),
+    );
+    expect(execute).toHaveBeenCalledWith({
+      aiRunId: RUN_ID,
+      projectId: PROJECT_ID,
+      suggestionId: SUGGESTION_ID,
+      attemptCount: 1,
+    });
+  });
+
+  test("a RemediationExecution run without a suggestion subject finalizes as Error", async () => {
+    const transition: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+    const execute: jest.SpyInstance = jest
+      .spyOn(RemediationExecutionRunner, "executeRemediation")
+      .mockResolvedValue(undefined);
+
+    await AIInvestigationQueue.processRun({
+      id: RUN_ID,
+      projectId: PROJECT_ID,
+      attemptCount: 0,
+      runType: AIRunType.RemediationExecution,
+    });
+
+    expect(execute).not.toHaveBeenCalled();
+    expect(transition).toHaveBeenCalledWith(
+      expect.objectContaining({
+        aiRunId: RUN_ID,
+        fromStatus: AIRunStatus.Running,
+        set: expect.objectContaining({
+          status: AIRunStatus.Error,
+        }),
+      }),
+    );
+  });
+
+  test("a RemediationExecution run stays Queued when the background lane is full", async () => {
+    /*
+     * Cap 3 => background sub-cap 2 (one slot reserved for interactive
+     * RCA). Global count 2 passes the cap; triage 1 + plans 1 = 2 fills
+     * the background lane.
+     */
+    jest
+      .spyOn(AIRunService, "countBy")
+      .mockResolvedValueOnce(new PositiveNumber(2))
+      .mockResolvedValueOnce(new PositiveNumber(1))
+      .mockResolvedValueOnce(new PositiveNumber(1));
+    const claim: jest.SpyInstance = jest
+      .spyOn(AIRunService, "attemptStatusTransition")
+      .mockResolvedValue(1);
+    const execute: jest.SpyInstance = jest
+      .spyOn(RemediationExecutionRunner, "executeRemediation")
+      .mockResolvedValue(undefined);
+
+    await AIInvestigationQueue.processRun({
+      id: RUN_ID,
+      projectId: PROJECT_ID,
+      attemptCount: 0,
+      runType: AIRunType.RemediationExecution,
+      triggeredByAutoRemediationSuggestionId: SUGGESTION_ID,
+    });
+
+    // No claim: the run must remain Queued for the poller / TTL.
+    expect(claim).not.toHaveBeenCalled();
+    expect(execute).not.toHaveBeenCalled();
+  });
+});