@oneuptime/common 12.0.5 → 12.0.7

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

@@ -15,13 +15,21 @@ import { describe, expect, test, afterEach } from "@jest/globals";
 
 /*
  * Human actions on AI insights land here via AIInsightAPI
- * (verdict / resolve / triage-run). Contract under test: a Dismissed
- * verdict also closes the insight while Confirmed leaves the status
- * untouched; overwriting a verdict is allowed (latest wins — this is the
- * G11 precision measurement, not an audit trail); resolve stamps Confirmed
- * only when no verdict exists yet; and the triage-run read returns the
+ * (verdict / resolve / reopen / triage-run). Contract under test: a
+ * Dismissed verdict also closes the insight while Confirmed leaves the
+ * status untouched — unless the insight was closed AS Dismissed, which
+ * Confirmed contradicts, so that case reopens it; overwriting a verdict is
+ * allowed (latest wins — this is the G11 precision measurement, not an
+ * audit trail); resolve stamps Confirmed only when no verdict exists yet;
+ * reopen undoes either terminal state and CLEARS the verdict, and is a
+ * no-op on an already-open insight; and the triage-run read returns the
  * empty { run: null, events: [] } shape instead of erroring, reading run +
  * events as root with the ordered, capped event query.
+ *
+ * Every human action must be reversible: hiding the actions on a closed
+ * insight (and having no reopen at all) made a mis-click permanent AND
+ * kept InsightStore's dismissal cooldown suppressing the same fingerprint
+ * for days, which is the regression the reopen tests below pin.
  */
 
 const insightId: ObjectID = ObjectID.generate();
@@ -44,11 +52,28 @@ describe("AIInsightService.applyHumanVerdict", () => {
     jest.restoreAllMocks();
   });
 
-  test("Confirmed: stores verdict + at + byUserId as root and leaves status untouched", async () => {
-    const findOneById: jest.SpyInstance = jest.spyOn(
+  test("missing insight → reject with a clear message, nothing written", async () => {
+    jest.spyOn(AIInsightService, "findOneById").mockResolvedValue(null);
+    const updateOneById: jest.SpyInstance = jest.spyOn(
       AIInsightService,
-      "findOneById",
+      "updateOneById",
     );
+
+    await expect(
+      AIInsightService.applyHumanVerdict({
+        insightId,
+        verdict: AIInsightHumanVerdict.Confirmed,
+        byUserId: userId,
+      }),
+    ).rejects.toThrow(BadDataException);
+
+    expect(updateOneById).not.toHaveBeenCalled();
+  });
+
+  test("Confirmed on an open insight: stores verdict + at + byUserId as root and leaves status untouched", async () => {
+    jest
+      .spyOn(AIInsightService, "findOneById")
+      .mockResolvedValue(fakeInsight({ status: AIInsightStatus.FixOpened }));
     const updateOneById: jest.SpyInstance = jest
       .spyOn(AIInsightService, "updateOneById")
       .mockResolvedValue(undefined as never);
@@ -56,6 +81,7 @@ describe("AIInsightService.applyHumanVerdict", () => {
     const result: {
       insightId: ObjectID;
       verdict: AIInsightHumanVerdict;
+      status: AIInsightStatus | null;
     } = await AIInsightService.applyHumanVerdict({
       insightId,
       verdict: AIInsightHumanVerdict.Confirmed,
@@ -64,6 +90,8 @@ describe("AIInsightService.applyHumanVerdict", () => {
 
     expect(result.insightId).toBe(insightId);
     expect(result.verdict).toBe(AIInsightHumanVerdict.Confirmed);
+    // Reported back unchanged — confirming did not move the lifecycle.
+    expect(result.status).toBe(AIInsightStatus.FixOpened);
 
     expect(updateOneById).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -77,16 +105,101 @@ describe("AIInsightService.applyHumanVerdict", () => {
       }),
     );
 
-    // Confirmed must NOT touch the lifecycle status.
+    // Confirmed must NOT touch the lifecycle status of an open insight.
     const updateArg: { data: Record<string, unknown> } = updateOneById.mock
       .calls[0]![0] as { data: Record<string, unknown> };
     expect(updateArg.data).not.toHaveProperty("status");
+  });
+
+  test("Confirmed on an insight closed as Dismissed: reopens it to ActionRequired", async () => {
+    /*
+     * "Closed as noise" and "a human says it was real" cannot both hold.
+     * Leaving the status alone here left the page showing Dismissed next to
+     * Confirmed with no way back, and left InsightStore suppressing the same
+     * fingerprint for the whole dismissal cooldown.
+     */
+    jest
+      .spyOn(AIInsightService, "findOneById")
+      .mockResolvedValue(fakeInsight({ status: AIInsightStatus.Dismissed }));
+    const updateOneById: jest.SpyInstance = jest
+      .spyOn(AIInsightService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    const result: {
+      insightId: ObjectID;
+      verdict: AIInsightHumanVerdict;
+      status: AIInsightStatus | null;
+    } = await AIInsightService.applyHumanVerdict({
+      insightId,
+      verdict: AIInsightHumanVerdict.Confirmed,
+      byUserId: userId,
+    });
+
+    expect(result.status).toBe(AIInsightStatus.ActionRequired);
+    expect(updateOneById).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          humanVerdict: AIInsightHumanVerdict.Confirmed,
+          status: AIInsightStatus.ActionRequired,
+        }),
+      }),
+    );
+  });
+
+  test("Confirmed on a dismissed insight with a fix task: reopens to FixOpened, not ActionRequired", async () => {
+    jest.spyOn(AIInsightService, "findOneById").mockResolvedValue(
+      fakeInsight({
+        status: AIInsightStatus.Dismissed,
+        fixAiRunId: ObjectID.generate(),
+      }),
+    );
+    const updateOneById: jest.SpyInstance = jest
+      .spyOn(AIInsightService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    await AIInsightService.applyHumanVerdict({
+      insightId,
+      verdict: AIInsightHumanVerdict.Confirmed,
+      byUserId: userId,
+    });
+
+    expect(updateOneById).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ status: AIInsightStatus.FixOpened }),
+      }),
+    );
+  });
 
-    // The write is unconditional — no read-before-write guard.
-    expect(findOneById).not.toHaveBeenCalled();
+  test("Confirmed on a Resolved insight leaves it Resolved (only Dismissed is contradicted)", async () => {
+    jest
+      .spyOn(AIInsightService, "findOneById")
+      .mockResolvedValue(fakeInsight({ status: AIInsightStatus.Resolved }));
+    const updateOneById: jest.SpyInstance = jest
+      .spyOn(AIInsightService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    const result: {
+      insightId: ObjectID;
+      verdict: AIInsightHumanVerdict;
+      status: AIInsightStatus | null;
+    } = await AIInsightService.applyHumanVerdict({
+      insightId,
+      verdict: AIInsightHumanVerdict.Confirmed,
+      byUserId: userId,
+    });
+
+    expect(result.status).toBe(AIInsightStatus.Resolved);
+    const updateArg: { data: Record<string, unknown> } = updateOneById.mock
+      .calls[0]![0] as { data: Record<string, unknown> };
+    expect(updateArg.data).not.toHaveProperty("status");
   });
 
   test("Dismissed: additionally closes the insight (status = Dismissed)", async () => {
+    jest
+      .spyOn(AIInsightService, "findOneById")
+      .mockResolvedValue(
+        fakeInsight({ status: AIInsightStatus.ActionRequired }),
+      );
     const updateOneById: jest.SpyInstance = jest
       .spyOn(AIInsightService, "updateOneById")
       .mockResolvedValue(undefined as never);
@@ -112,6 +225,11 @@ describe("AIInsightService.applyHumanVerdict", () => {
      * There is deliberately no "already has a verdict" guard — people
      * change their minds, and the G11 measurement wants the latest call.
      */
+    jest
+      .spyOn(AIInsightService, "findOneById")
+      .mockResolvedValue(
+        fakeInsight({ status: AIInsightStatus.ActionRequired }),
+      );
     const updateOneById: jest.SpyInstance = jest
       .spyOn(AIInsightService, "updateOneById")
       .mockResolvedValue(undefined as never);
@@ -126,6 +244,7 @@ describe("AIInsightService.applyHumanVerdict", () => {
     const result: {
       insightId: ObjectID;
       verdict: AIInsightHumanVerdict;
+      status: AIInsightStatus | null;
     } = await AIInsightService.applyHumanVerdict({
       insightId,
       verdict: AIInsightHumanVerdict.Dismissed,
@@ -146,6 +265,117 @@ describe("AIInsightService.applyHumanVerdict", () => {
   });
 });
 
+describe("AIInsightService.reopenInsight", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("missing insight → reject with a clear message, nothing written", async () => {
+    jest.spyOn(AIInsightService, "findOneById").mockResolvedValue(null);
+    const updateOneById: jest.SpyInstance = jest.spyOn(
+      AIInsightService,
+      "updateOneById",
+    );
+
+    await expect(AIInsightService.reopenInsight({ insightId })).rejects.toThrow(
+      BadDataException,
+    );
+
+    expect(updateOneById).not.toHaveBeenCalled();
+  });
+
+  test("Dismissed → ActionRequired, and the verdict fields are cleared", async () => {
+    /*
+     * Clearing is the point: a verdict the human took back must stop
+     * counting toward per-detector precision, and a stale humanVerdictAt
+     * would otherwise anchor InsightStore's dismissal cooldown.
+     */
+    jest.spyOn(AIInsightService, "findOneById").mockResolvedValue(
+      fakeInsight({
+        status: AIInsightStatus.Dismissed,
+        humanVerdict: AIInsightHumanVerdict.Dismissed,
+      }),
+    );
+    const updateOneById: jest.SpyInstance = jest
+      .spyOn(AIInsightService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    const result: { insightId: ObjectID; status: AIInsightStatus } =
+      await AIInsightService.reopenInsight({ insightId });
+
+    expect(result.status).toBe(AIInsightStatus.ActionRequired);
+
+    expect(updateOneById).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: insightId,
+        props: expect.objectContaining({ isRoot: true }),
+      }),
+    );
+
+    const updateArg: { data: Record<string, unknown> } = updateOneById.mock
+      .calls[0]![0] as { data: Record<string, unknown> };
+    expect(updateArg.data["status"]).toBe(AIInsightStatus.ActionRequired);
+    // Explicit nulls — undefined would leave the columns as they were.
+    expect(updateArg.data["humanVerdict"]).toBeNull();
+    expect(updateArg.data["humanVerdictAt"]).toBeNull();
+    expect(updateArg.data["humanVerdictByUserId"]).toBeNull();
+  });
+
+  test("Resolved → ActionRequired too: both terminal states are reversible", async () => {
+    jest.spyOn(AIInsightService, "findOneById").mockResolvedValue(
+      fakeInsight({
+        status: AIInsightStatus.Resolved,
+        humanVerdict: AIInsightHumanVerdict.Confirmed,
+      }),
+    );
+    const updateOneById: jest.SpyInstance = jest
+      .spyOn(AIInsightService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    const result: { insightId: ObjectID; status: AIInsightStatus } =
+      await AIInsightService.reopenInsight({ insightId });
+
+    expect(result.status).toBe(AIInsightStatus.ActionRequired);
+    expect(updateOneById).toHaveBeenCalledTimes(1);
+  });
+
+  test("a closed insight with a fix task reopens to FixOpened", async () => {
+    jest.spyOn(AIInsightService, "findOneById").mockResolvedValue(
+      fakeInsight({
+        status: AIInsightStatus.Resolved,
+        fixAiRunId: ObjectID.generate(),
+      }),
+    );
+    const updateOneById: jest.SpyInstance = jest
+      .spyOn(AIInsightService, "updateOneById")
+      .mockResolvedValue(undefined as never);
+
+    const result: { insightId: ObjectID; status: AIInsightStatus } =
+      await AIInsightService.reopenInsight({ insightId });
+
+    expect(result.status).toBe(AIInsightStatus.FixOpened);
+    const updateArg: { data: Record<string, unknown> } = updateOneById.mock
+      .calls[0]![0] as { data: Record<string, unknown> };
+    expect(updateArg.data["status"]).toBe(AIInsightStatus.FixOpened);
+  });
+
+  test("already open: no-op that reports the current status (a double click cannot rewrite it)", async () => {
+    jest
+      .spyOn(AIInsightService, "findOneById")
+      .mockResolvedValue(fakeInsight({ status: AIInsightStatus.FixOpened }));
+    const updateOneById: jest.SpyInstance = jest.spyOn(
+      AIInsightService,
+      "updateOneById",
+    );
+
+    const result: { insightId: ObjectID; status: AIInsightStatus } =
+      await AIInsightService.reopenInsight({ insightId });
+
+    expect(result.status).toBe(AIInsightStatus.FixOpened);
+    expect(updateOneById).not.toHaveBeenCalled();
+  });
+});
+
 describe("AIInsightService.resolveInsight", () => {
   afterEach(() => {
     jest.restoreAllMocks();
@@ -219,6 +449,31 @@ describe("AIInsightService.resolveInsight", () => {
     expect(Object.keys(updateArg.data)).toEqual(["status"]);
     expect(updateArg.data["status"]).toBe(AIInsightStatus.Resolved);
   });
+
+  /*
+   * The store's re-file cooldown is keyed on the CURRENT terminal status, so
+   * flipping a Dismissed insight to Resolved would silently trade a
+   * dismissal's 7-day quiet for a resolve's 24-hour one — a finding a human
+   * called noise would come back. The dashboard hides the action on terminal
+   * insights; this closes the API path.
+   */
+  test.each([[AIInsightStatus.Dismissed], [AIInsightStatus.Resolved]])(
+    "an already-%s insight cannot be resolved again — nothing is written",
+    async (status: AIInsightStatus) => {
+      jest
+        .spyOn(AIInsightService, "findOneById")
+        .mockResolvedValue(fakeInsight({ status }));
+      const updateOneById: jest.SpyInstance = jest
+        .spyOn(AIInsightService, "updateOneById")
+        .mockResolvedValue(undefined as never);
+
+      await expect(
+        AIInsightService.resolveInsight({ insightId, byUserId: userId }),
+      ).rejects.toThrow(BadDataException);
+
+      expect(updateOneById).not.toHaveBeenCalled();
+    },
+  );
 });
 
 describe("AIInsightService.getLatestTriageRunWithEvents", () => {

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

@@ -0,0 +1,160 @@
+import AIRunService from "../../../Server/Services/AIRunService";
+import AIRunStatus from "../../../Types/AI/AIRunStatus";
+import ObjectID from "../../../Types/ObjectID";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * setInvestigationAnalysisTldr writes display-only text, but it still must be
+ * scoped: only the run it summarizes, only while that run is Completed, and
+ * never a soft-deleted row. A stale attempt that lost the completion race (so
+ * never posts a report) must not be able to label the run either.
+ */
+
+interface RecordedQuery {
+  set: Record<string, unknown> | null;
+  wheres: Array<{ clause: string; parameters: Record<string, unknown> }>;
+}
+
+function mockUpdateQueryBuilder(data: { affected: number | undefined }): {
+  recorded: RecordedQuery;
+} {
+  const recorded: RecordedQuery = { set: null, wheres: [] };
+
+  const builder: Record<string, unknown> = {
+    update: () => {
+      return builder;
+    },
+    set: (values: Record<string, unknown>) => {
+      recorded.set = values;
+      return builder;
+    },
+    where: (clause: string, parameters: Record<string, unknown>) => {
+      recorded.wheres.push({ clause, parameters });
+      return builder;
+    },
+    andWhere: (clause: string, parameters?: Record<string, unknown>) => {
+      recorded.wheres.push({ clause, parameters: parameters || {} });
+      return builder;
+    },
+    execute: async () => {
+      return { affected: data.affected };
+    },
+  };
+
+  jest.spyOn(AIRunService, "getRepository").mockReturnValue({
+    createQueryBuilder: () => {
+      return builder;
+    },
+  } as never);
+
+  return { recorded };
+}
+
+function whereClauses(recorded: RecordedQuery): string {
+  return recorded.wheres
+    .map((where: { clause: string }): string => {
+      return where.clause;
+    })
+    .join(" AND ");
+}
+
+describe("AIRunService.setInvestigationAnalysisTldr", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("writes only the summary, scoped to that Completed, undeleted run", async () => {
+    const aiRunId: ObjectID = ObjectID.generate();
+    const { recorded } = mockUpdateQueryBuilder({ affected: 1 });
+
+    await expect(
+      AIRunService.setInvestigationAnalysisTldr({
+        aiRunId,
+        analysisTldr: "Checkout is failing on an exhausted pool.",
+      }),
+    ).resolves.toBe(1);
+
+    expect(recorded.set).toEqual({
+      analysisTldr: "Checkout is failing on an exhausted pool.",
+    });
+
+    const clauses: string = whereClauses(recorded);
+    expect(clauses).toContain('"_id" = :id');
+    expect(clauses).toContain('"status" = :status');
+    expect(clauses).toContain('"deletedAt" IS NULL');
+    expect(recorded.wheres[0]!.parameters).toEqual({
+      id: aiRunId.toString(),
+    });
+    expect(recorded.wheres[1]!.parameters).toEqual({
+      status: AIRunStatus.Completed,
+    });
+  });
+
+  /*
+   * A display-only writer must not be able to touch anything else. This is
+   * the only thing standing between "set one varchar" and an UPDATE that
+   * silently rewrites status or the code-fix decision on a settled run.
+   */
+  test("writes that column and nothing else", async () => {
+    const { recorded } = mockUpdateQueryBuilder({ affected: 1 });
+
+    await AIRunService.setInvestigationAnalysisTldr({
+      aiRunId: ObjectID.generate(),
+      analysisTldr: "Summary of the outage.",
+    });
+
+    expect(Object.keys(recorded.set || {})).toEqual(["analysisTldr"]);
+  });
+
+  /*
+   * Write-once. A stale attempt that lost the Completed CAS is kept out today
+   * only by statement order in the engine — and by the time it could run, the
+   * WINNER has already written both the report and its summary, so a
+   * status-only guard would let the loser overwrite a summary describing a
+   * different analysis.
+   */
+  test("refuses to overwrite a summary that already exists", async () => {
+    const aiRunId: ObjectID = ObjectID.generate();
+    const { recorded } = mockUpdateQueryBuilder({ affected: 1 });
+
+    await AIRunService.setInvestigationAnalysisTldr({
+      aiRunId,
+      analysisTldr: "Summary of the outage.",
+    });
+
+    expect(whereClauses(recorded)).toContain('"analysisTldr" IS NULL');
+  });
+
+  test("reports zero when another writer already summarized the run", async () => {
+    mockUpdateQueryBuilder({ affected: 0 });
+
+    await expect(
+      AIRunService.setInvestigationAnalysisTldr({
+        aiRunId: ObjectID.generate(),
+        analysisTldr: "A second, conflicting summary.",
+      }),
+    ).resolves.toBe(0);
+  });
+
+  test("reports zero when the run is no longer Completed", async () => {
+    mockUpdateQueryBuilder({ affected: 0 });
+
+    await expect(
+      AIRunService.setInvestigationAnalysisTldr({
+        aiRunId: ObjectID.generate(),
+        analysisTldr: "Summary.",
+      }),
+    ).resolves.toBe(0);
+  });
+
+  test("treats an undefined affected count as no rows changed", async () => {
+    mockUpdateQueryBuilder({ affected: undefined });
+
+    await expect(
+      AIRunService.setInvestigationAnalysisTldr({
+        aiRunId: ObjectID.generate(),
+        analysisTldr: "Summary.",
+      }),
+    ).resolves.toBe(0);
+  });
+});

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

@@ -8,6 +8,7 @@ import AIService, {
   AI_INCIDENT_INVESTIGATION_FEATURE,
   AI_INSIGHT_TRIAGE_FEATURE,
   AI_INVESTIGATION_GRADING_FEATURE,
+  AI_INVESTIGATION_TLDR_FEATURE,
   AI_REMEDIATION_EXECUTION_FEATURE,
   AI_REMEDIATION_PLANNING_FEATURE,
   RUNBOOK_AI_STEP_FEATURE,
@@ -77,6 +78,7 @@ describe("AUTONOMOUS_AI_FEATURES persisted labels", () => {
     expect(AI_CONFIDENCE_CLASSIFICATION_FEATURE).toBe(
       "AI Confidence Classification",
     );
+    expect(AI_INVESTIGATION_TLDR_FEATURE).toBe("AI Investigation TLDR");
     expect(AI_CODE_FIX_FEATURE).toBe("AI Code Fix");
     expect(AI_INSIGHT_TRIAGE_FEATURE).toBe("AI Insight Triage");
     expect(AI_REMEDIATION_PLANNING_FEATURE).toBe("AI Remediation Planning");
@@ -91,6 +93,7 @@ describe("AUTONOMOUS_AI_FEATURES persisted labels", () => {
       AI_ALERT_INVESTIGATION_FEATURE,
       AI_INVESTIGATION_GRADING_FEATURE,
       AI_CONFIDENCE_CLASSIFICATION_FEATURE,
+      AI_INVESTIGATION_TLDR_FEATURE,
       AI_CODE_FIX_FEATURE,
       AI_INSIGHT_TRIAGE_FEATURE,
       AI_REMEDIATION_PLANNING_FEATURE,
@@ -136,6 +139,7 @@ describe("AUTONOMOUS_AI_FEATURES persisted labels", () => {
         AI_ALERT_INVESTIGATION_FEATURE,
         AI_INVESTIGATION_GRADING_FEATURE,
         AI_CONFIDENCE_CLASSIFICATION_FEATURE,
+        AI_INVESTIGATION_TLDR_FEATURE,
         AI_CODE_FIX_FEATURE,
         AI_INSIGHT_TRIAGE_FEATURE,
         AI_REMEDIATION_PLANNING_FEATURE,