@oneuptime/common 13.0.1 → 13.0.4

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

@@ -454,18 +454,16 @@ describe("UserService.onBeforeUpdate — a password reset link dies with the add
       expect(stubs.findBy).toHaveBeenCalledTimes(1);
     });
 
-    test("turning off two factor auth as a non-root caller is still refused", async () => {
-      /*
-       * The guard that lives immediately after the new code in the same hook.
-       * Cheap to assert here, and it is the thing an edit to this method is
-       * most likely to displace.
-       */
+    test("turning off two factor auth on another account is still refused", async () => {
       await expect(
         userService().onBeforeUpdate(
-          updatePayload({ patch: { enableTwoFactorAuth: false } }),
+          updatePayload({
+            patch: { enableTwoFactorAuth: false },
+            query: { _id: OTHER_USER_ID.toString() },
+          }),
         ),
       ).rejects.toThrow(
-        "Only an administrator can turn off two factor authentication for this account.",
+        "You can only turn off two factor authentication for your own account.",
       );
     });
   });

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

@@ -6,6 +6,9 @@ import UserWebAuthnService from "../../../Server/Services/UserWebAuthnService";
 import UserTwoFactorBackupCodeService from "../../../Server/Services/UserTwoFactorBackupCodeService";
 import logger from "../../../Server/Utils/Logger";
 import User from "../../../Models/DatabaseModels/User";
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import NotEqual from "../../../Types/BaseDatabase/NotEqual";
 import ColumnLength from "../../../Types/Database/ColumnLength";
 import LIMIT_MAX from "../../../Types/Database/LimitMax";
 import Email from "../../../Types/Email";
@@ -901,50 +904,216 @@ describe("UserService -- admin-controlled two factor auth", () => {
       ).onBeforeUpdate(updateBy);
     };
 
-    /*
-     * ---------------------------------------------------------------------
-     * The guard that REPLACED the deleted one, and the reason it had to
-     * exist at all.
-     *
-     * `enableTwoFactorAuth` carries `update: [Permission.CurrentUser]`
-     * (Common/Models/DatabaseModels/User.ts) and the User table's row ACL
-     * scopes updates to the caller's own id, so every signed-in user can
-     * write their own copy of this flag through the ordinary CRUD API -- and
-     * the product ships the button that does it, at Dashboard > Profile >
-     * Two Factor Authentication.
-     *
-     * Without the guard the whole feature is self-undoing: the admin requires
-     * two factor auth, the user is marched through enrolment at their next
-     * sign-in, and then from the session they just earned they flip the
-     * toggle back off and delete the factor -- which the removal of the
-     * onBeforeDelete guards now also permits. The account is password-only
-     * again and the Authentication page reports the mandate as simply absent.
-     * ---------------------------------------------------------------------
-     */
-    test("onBeforeUpdate refuses to let a non-root caller turn the requirement OFF", async () => {
+    type InvalidTwoFactorFlag = { label: string; value: unknown };
+    const invalidTwoFactorFlags: Array<InvalidTwoFactorFlag> = [
+      { label: 'the string "false"', value: "false" },
+      { label: 'the string "true"', value: "true" },
+      { label: "an empty string", value: "" },
+      { label: "zero", value: 0 },
+      { label: "one", value: 1 },
+      { label: "null", value: null },
+      { label: "an array", value: [] },
+      { label: "an object", value: {} },
+    ];
+
+    describe.each(["owner", "master admin", "root"])(
+      "%s flag validation",
+      (caller: string): void => {
+        test.each(invalidTwoFactorFlags)(
+          `rejects $label as a two factor auth flag for ${caller}`,
+          async ({ value }: InvalidTwoFactorFlag) => {
+            await expect(
+              callOnBeforeUpdate({
+                query: {
+                  _id: (caller === "owner" ? userId : foundUserId).toString(),
+                },
+                data: { enableTwoFactorAuth: value },
+                props: {
+                  userId: userId,
+                  isMasterAdmin: caller === "master admin",
+                  isRoot: caller === "root",
+                },
+              }),
+            ).rejects.toThrow("enableTwoFactorAuth must be a boolean.");
+          },
+        );
+      },
+    );
+
+    test("rejects a malformed flag before email and password change side effects", async () => {
       await expect(
         callOnBeforeUpdate({
-          query: { _id: userId },
-          data: { enableTwoFactorAuth: false },
-          props: {},
+          query: { _id: userId.toString() },
+          data: {
+            enableTwoFactorAuth: "false",
+            email: new Email("changed@example.com"),
+            password: new HashedString("a new password"),
+          },
+          props: { userId: userId },
         }),
-      ).rejects.toThrow(BadDataException);
+      ).rejects.toThrow("enableTwoFactorAuth must be a boolean.");
+      expect(findBySpy).not.toHaveBeenCalled();
+      expect(updateBySpy).not.toHaveBeenCalled();
+      expect(revokeSessionsSpy).not.toHaveBeenCalled();
     });
 
-    test("the refusal names an administrator, so the user knows who to ask", async () => {
-      /*
-       * The message is the only thing the user sees when the profile toggle
-       * refuses. "Bad data" would send them to support with nothing to say.
-       */
+    test("ignores an undefined flag on an unrelated profile update", async () => {
       await expect(
         callOnBeforeUpdate({
-          query: { _id: userId },
-          data: { enableTwoFactorAuth: false },
-          props: {},
+          query: { _id: userId.toString() },
+          data: { name: "Someone", enableTwoFactorAuth: undefined },
+          props: { userId: userId },
         }),
-      ).rejects.toThrow(/administrator/i);
+      ).resolves.toBeDefined();
     });
 
+    /*
+     * The hook runs before row permissions scope a query. Self-service must
+     * therefore identify exactly the caller's row, including the string id
+     * produced by the real updateOneById path. Query operators may stringify
+     * to the caller's id while selecting other users, so they stay forbidden.
+     */
+    describe.each([false, true])(
+      "self-service ownership (master admin: %s)",
+      (isMasterAdmin: boolean): void => {
+        test.each(["string", "ObjectID"])(
+          `allows the owner to turn off two factor auth with a %s id: master admin ${isMasterAdmin}`,
+          async (idType: string) => {
+            const updateBy: {
+              query: { _id: string | ObjectID };
+              data: { enableTwoFactorAuth: boolean };
+              props: DatabaseCommonInteractionProps;
+              limit: number;
+              skip: number;
+            } = {
+              query: {
+                _id: idType === "string" ? userId.toString() : userId,
+              },
+              data: { enableTwoFactorAuth: false },
+              props: { userId, isMasterAdmin, isRoot: false },
+              limit: 1,
+              skip: 0,
+            };
+
+            const result: { updateBy: unknown; carryForward: Array<User> } =
+              await callOnBeforeUpdate(updateBy);
+
+            expect(result.updateBy).toBe(updateBy);
+            expect(result.carryForward).toEqual([]);
+            expect(findBySpy).not.toHaveBeenCalled();
+            expect(revokeSessionsSpy).not.toHaveBeenCalled();
+            expect(totpDeleteBySpy).not.toHaveBeenCalled();
+            expect(webAuthnDeleteBySpy).not.toHaveBeenCalled();
+          },
+        );
+
+        type RejectedQueryCase = {
+          label: string;
+          query: (ownerId: ObjectID, otherId: ObjectID) => unknown;
+        };
+
+        const rejectedQueries: Array<RejectedQueryCase> = [
+          {
+            label: "another user's string id",
+            query: (_ownerId: ObjectID, otherId: ObjectID): unknown => {
+              return { _id: otherId.toString() };
+            },
+          },
+          {
+            label: "another user's ObjectID",
+            query: (_ownerId: ObjectID, otherId: ObjectID): unknown => {
+              return { _id: otherId };
+            },
+          },
+          {
+            label: "a bulk query with no id",
+            query: (): unknown => {
+              return {};
+            },
+          },
+          {
+            label: "a missing query",
+            query: (): unknown => {
+              return undefined;
+            },
+          },
+          {
+            label: "a null id",
+            query: (): unknown => {
+              return { _id: null };
+            },
+          },
+          {
+            label: "a query array containing the owner",
+            query: (ownerId: ObjectID): unknown => {
+              return [{ _id: ownerId }];
+            },
+          },
+          {
+            label: "a query array containing another account",
+            query: (ownerId: ObjectID, otherId: ObjectID): unknown => {
+              return [{ _id: ownerId }, { _id: otherId }];
+            },
+          },
+          {
+            label: "a NotEqual predicate that stringifies to the owner",
+            query: (ownerId: ObjectID): unknown => {
+              return { _id: new NotEqual(ownerId.toString()) };
+            },
+          },
+          {
+            label: "an Includes predicate containing another account",
+            query: (ownerId: ObjectID, otherId: ObjectID): unknown => {
+              return { _id: new Includes([ownerId, otherId]) };
+            },
+          },
+          {
+            label: "an array of ids",
+            query: (ownerId: ObjectID): unknown => {
+              return { _id: [ownerId] };
+            },
+          },
+          {
+            label: "an object that stringifies to the owner",
+            query: (ownerId: ObjectID): unknown => {
+              return {
+                _id: {
+                  toString: (): string => {
+                    return ownerId.toString();
+                  },
+                },
+              };
+            },
+          },
+        ];
+
+        test.each(rejectedQueries)(
+          `rejects $label when turning off two factor auth: master admin ${isMasterAdmin}`,
+          async ({ query }: RejectedQueryCase) => {
+            await expect(
+              callOnBeforeUpdate({
+                query: query(userId, foundUserId),
+                data: { enableTwoFactorAuth: false },
+                props: { userId, isMasterAdmin },
+                limit: LIMIT_MAX,
+                skip: 0,
+              }),
+            ).rejects.toThrow(BadDataException);
+          },
+        );
+
+        test(`rejects disabling without an authenticated owner: master admin ${isMasterAdmin}`, async () => {
+          await expect(
+            callOnBeforeUpdate({
+              query: { _id: userId.toString() },
+              data: { enableTwoFactorAuth: false },
+              props: { isMasterAdmin },
+            }),
+          ).rejects.toThrow(/your own account/i);
+        });
+      },
+    );
+
     test("a ROOT caller may turn the requirement off -- that is the admin endpoint", async () => {
       /*
        * setTwoFactorAuthRequired({ isRequired: false }) writes with

package/Tests/Server/Types/Database/QueryHelperJsonArrayObjects.test.ts

@@ -0,0 +1,128 @@
+import QueryHelper from "../../../../Server/Types/Database/QueryHelper";
+import LIMIT_MAX from "../../../../Types/Database/LimitMax";
+import ObjectID from "../../../../Types/ObjectID";
+import { FindOperator } from "typeorm";
+import { describe, expect, it } from "@jest/globals";
+
+interface RawOperator {
+  type: string;
+  objectLiteralParameters: Record<string, unknown>;
+  getSql: (aliasPath: string) => string;
+}
+
+function asRaw(operator: unknown): RawOperator {
+  return operator as RawOperator;
+}
+
+const CRITERIA_ALIAS: string = '"StatusPageMonitorRule"."criteria"';
+
+describe("QueryHelper.jsonArrayObjectsContainAnyArrayValue", () => {
+  it("renders a guarded jsonb membership predicate", () => {
+    const operator: RawOperator = asRaw(
+      QueryHelper.jsonArrayObjectsContainAnyArrayValue({
+        arrayKey: "filters",
+        discriminatorKey: "field",
+        discriminatorValue: "monitorLabels",
+        valueArrayKey: "value",
+        values: [
+          new ObjectID("11111111-1111-4111-8111-111111111111"),
+          "22222222-2222-4222-8222-222222222222",
+        ],
+      }),
+    );
+
+    const sql: string = operator.getSql(CRITERIA_ALIAS);
+
+    expect(operator).toBeInstanceOf(FindOperator);
+    expect(operator.type).toBe("raw");
+    expect(sql).toContain("EXISTS (SELECT 1 FROM jsonb_array_elements(");
+    expect(sql).toContain("jsonb_array_elements_text(");
+    expect(sql).toContain("jsonb_typeof(");
+    expect(sql).toContain("ELSE '[]'::jsonb END");
+    expect(sql).toContain("= ANY(CAST(:");
+    expect(sql).toContain("AS text[]))");
+  });
+
+  it("binds every document key, discriminator, and value instead of interpolating user data", () => {
+    const maliciousValue: string =
+      "11111111-1111-4111-8111-111111111111'); DROP TABLE Label; --";
+    const operator: RawOperator = asRaw(
+      QueryHelper.jsonArrayObjectsContainAnyArrayValue({
+        arrayKey: "filters' unsafe",
+        discriminatorKey: "field' unsafe",
+        discriminatorValue: "monitorLabels' unsafe",
+        valueArrayKey: "value' unsafe",
+        values: [maliciousValue],
+      }),
+    );
+
+    const sql: string = operator.getSql(CRITERIA_ALIAS);
+    const parameters: Array<unknown> = Object.values(
+      operator.objectLiteralParameters,
+    );
+
+    expect(Object.keys(operator.objectLiteralParameters)).toHaveLength(5);
+    expect(parameters).toContain("filters' unsafe");
+    expect(parameters).toContain("field' unsafe");
+    expect(parameters).toContain("monitorLabels' unsafe");
+    expect(parameters).toContain("value' unsafe");
+    expect(parameters).toContainEqual([maliciousValue]);
+    expect(sql).not.toContain("unsafe");
+    expect(sql).not.toContain("DROP TABLE");
+  });
+
+  it("deduplicates ids before binding them as one text-array parameter", () => {
+    const id: ObjectID = new ObjectID("11111111-1111-4111-8111-111111111111");
+    const operator: RawOperator = asRaw(
+      QueryHelper.jsonArrayObjectsContainAnyArrayValue({
+        arrayKey: "filters",
+        discriminatorKey: "field",
+        discriminatorValue: "monitorLabels",
+        valueArrayKey: "value",
+        values: [id, id.toString(), id],
+      }),
+    );
+
+    const boundArrays: Array<unknown> = Object.values(
+      operator.objectLiteralParameters,
+    ).filter((value: unknown): boolean => {
+      return Array.isArray(value);
+    });
+
+    expect(boundArrays).toEqual([[id.toString()]]);
+  });
+
+  it("returns an always-false predicate for an empty value list", () => {
+    const operator: RawOperator = asRaw(
+      QueryHelper.jsonArrayObjectsContainAnyArrayValue({
+        arrayKey: "filters",
+        discriminatorKey: "field",
+        discriminatorValue: "monitorLabels",
+        valueArrayKey: "value",
+        values: [],
+      }),
+    );
+
+    expect(operator.getSql(CRITERIA_ALIAS)).toBe("TRUE = FALSE");
+    expect(operator.objectLiteralParameters).toEqual({});
+  });
+
+  it("rejects more unique values than a bounded database read can produce", () => {
+    const values: Array<string> = Array.from(
+      { length: LIMIT_MAX + 1 },
+      (_value: unknown, index: number): string => {
+        return `label-${index}`;
+      },
+    );
+
+    expect(() => {
+      QueryHelper.jsonArrayObjectsContainAnyArrayValue({
+        arrayKey: "filters",
+        discriminatorKey: "field",
+        discriminatorValue: "monitorLabels",
+        valueArrayKey: "value",
+        values: values,
+      });
+    }).toThrow(`cannot bind more than ${LIMIT_MAX} unique values`);
+  });
+});

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

@@ -8,6 +8,7 @@ import ServiceLevelObjectiveBurnRateRuleService from "../../../../Server/Service
 import ServiceLevelObjective from "../../../../Models/DatabaseModels/ServiceLevelObjective";
 import ServiceLevelObjectiveBurnRateRule from "../../../../Models/DatabaseModels/ServiceLevelObjectiveBurnRateRule";
 import AlertSeverity from "../../../../Models/DatabaseModels/AlertSeverity";
+import IncidentSeverity from "../../../../Models/DatabaseModels/IncidentSeverity";
 import Monitor from "../../../../Models/DatabaseModels/Monitor";
 import { AIChatCitationTargetType } from "../../../../Types/AI/AIChatTypes";
 import { JSONObject } from "../../../../Types/JSON";
@@ -24,7 +25,10 @@ import { afterEach, describe, expect, test } from "@jest/globals";
  * returns the definition, persisted compliance and burn-rate rules for one
  * SLO; the list mode respects clamps, pagination and the status filter;
  * compliance is always labeled as persisted (never recomputed); and empty
- * results are honest (rowCount 0, no widget).
+ * results are honest (rowCount 0, no widget). Since a burn-rate rule can now
+ * raise an alert, declare an incident, or both, the rule rows also have to
+ * report each output — with the model's defaults applied, so a rule written
+ * before incidents existed is not handed to the LLM as a blank.
  */
 
 const ctx: ToolContext = {
@@ -73,9 +77,20 @@ function buildSlo(data?: {
   return slo;
 }
 
+/*
+ * shouldCreateAlert / shouldCreateIncident and the incident columns are left
+ * unset unless a case asks for them: that is exactly the shape of a rule row
+ * written before burn-rate rules could declare incidents, which is the case
+ * the serializer's defaults exist for.
+ */
 function buildRule(data?: {
   name?: string;
   threshold?: number;
+  shouldCreateAlert?: boolean;
+  shouldCreateIncident?: boolean;
+  incidentSeverity?: string;
+  lastIncidentCreatedAt?: Date;
+  lastIncidentResolvedAt?: Date;
 }): ServiceLevelObjectiveBurnRateRule {
   const rule: ServiceLevelObjectiveBurnRateRule =
     new ServiceLevelObjectiveBurnRateRule();
@@ -90,6 +105,28 @@ function buildRule(data?: {
   severity.name = "Critical";
   rule.alertSeverity = severity;
 
+  if (data?.shouldCreateAlert !== undefined) {
+    rule.shouldCreateAlert = data.shouldCreateAlert;
+  }
+
+  if (data?.shouldCreateIncident !== undefined) {
+    rule.shouldCreateIncident = data.shouldCreateIncident;
+  }
+
+  if (data?.incidentSeverity) {
+    const incidentSeverity: IncidentSeverity = new IncidentSeverity();
+    incidentSeverity.name = data.incidentSeverity;
+    rule.incidentSeverity = incidentSeverity;
+  }
+
+  if (data?.lastIncidentCreatedAt) {
+    rule.lastIncidentCreatedAt = data.lastIncidentCreatedAt;
+  }
+
+  if (data?.lastIncidentResolvedAt) {
+    rule.lastIncidentResolvedAt = data.lastIncidentResolvedAt;
+  }
+
   return rule;
 }
 
@@ -162,6 +199,158 @@ describe("query_slos — detail mode", () => {
   });
 });
 
+/*
+ * A burn-rate rule has two independent outputs — an alert and an incident —
+ * each with its own severity and its own created/resolved stamps. The model
+ * answers "what happens when this rule fires?" purely from these fields, so
+ * both halves are pinned: the select that reaches the database (an unselected
+ * column comes back undefined and quietly reads as its default) and the
+ * serialized row the LLM actually sees.
+ */
+describe("query_slos — burn-rate rule outputs", () => {
+  test("selects both output lifecycles for each rule", async () => {
+    jest
+      .spyOn(ServiceLevelObjectiveService, "findOneById")
+      .mockResolvedValue(buildSlo() as never);
+    const rulesSpy: jest.SpyInstance = jest
+      .spyOn(ServiceLevelObjectiveBurnRateRuleService, "findBy")
+      .mockResolvedValue([] as never);
+
+    await QuerySlosTool.execute({ sloId: SLO_ID.toString() }, ctx);
+
+    const select: JSONObject = (rulesSpy.mock.calls[0]?.[0] as JSONObject)[
+      "select"
+    ] as JSONObject;
+
+    expect(select["shouldCreateAlert"]).toBe(true);
+    expect(select["alertSeverity"]).toEqual({ name: true });
+    expect(select["lastAlertCreatedAt"]).toBe(true);
+    expect(select["lastAlertResolvedAt"]).toBe(true);
+    expect(select["shouldCreateIncident"]).toBe(true);
+    expect(select["incidentSeverity"]).toEqual({ name: true });
+    expect(select["lastIncidentCreatedAt"]).toBe(true);
+    expect(select["lastIncidentResolvedAt"]).toBe(true);
+  });
+
+  test("a rule that alerts and declares an incident reports both, with both severities and both stamps", async () => {
+    jest
+      .spyOn(ServiceLevelObjectiveService, "findOneById")
+      .mockResolvedValue(buildSlo() as never);
+    jest
+      .spyOn(ServiceLevelObjectiveBurnRateRuleService, "findBy")
+      .mockResolvedValue([
+        buildRule({
+          name: "Fast burn",
+          shouldCreateAlert: true,
+          shouldCreateIncident: true,
+          incidentSeverity: "Sev1",
+          lastIncidentCreatedAt: new Date("2026-08-14T10:00:00Z"),
+          lastIncidentResolvedAt: new Date("2026-08-14T11:30:00Z"),
+        }),
+      ] as never);
+
+    const result: ToolExecutionResult = await QuerySlosTool.execute(
+      { sloId: SLO_ID.toString() },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("createsAlert=true");
+    expect(result.dataForLlm).toContain("alertSeverity=Critical");
+    expect(result.dataForLlm).toContain("createsIncident=true");
+    expect(result.dataForLlm).toContain("incidentSeverity=Sev1");
+    /*
+     * The incident stamps are a lifecycle of their own — the model reads them
+     * to say whether the declared incident is still open, so they must not be
+     * folded into or shadowed by the alert stamps.
+     */
+    expect(result.dataForLlm).toContain(
+      "lastIncidentCreatedAt=2026-08-14T10:00:00.000Z",
+    );
+    expect(result.dataForLlm).toContain(
+      "lastIncidentResolvedAt=2026-08-14T11:30:00.000Z",
+    );
+  });
+
+  test("a rule written before this feature reads as alerts-only, never as a blank", async () => {
+    jest
+      .spyOn(ServiceLevelObjectiveService, "findOneById")
+      .mockResolvedValue(buildSlo() as never);
+    jest
+      .spyOn(ServiceLevelObjectiveBurnRateRuleService, "findBy")
+      // Neither flag set, i.e. a rule row that predates the incident columns.
+      .mockResolvedValue([buildRule({ name: "Legacy burn" })] as never);
+
+    const result: ToolExecutionResult = await QuerySlosTool.execute(
+      { sloId: SLO_ID.toString() },
+      ctx,
+    );
+
+    /*
+     * The model's defaults (alert on, incident off) must be applied here
+     * rather than emitted as an absent field: a missing createsAlert would
+     * leave the LLM guessing whether an old rule pages anyone at all.
+     */
+    expect(result.dataForLlm).toContain("createsAlert=true");
+    expect(result.dataForLlm).toContain("createsIncident=false");
+    expect(result.dataForLlm).not.toContain("createsAlert=false");
+    expect(result.dataForLlm).not.toContain("createsIncident=true");
+  });
+
+  test("an explicit shouldCreateAlert=false is honoured, so an incident-only rule never reads as alerting", async () => {
+    jest
+      .spyOn(ServiceLevelObjectiveService, "findOneById")
+      .mockResolvedValue(buildSlo() as never);
+    jest
+      .spyOn(ServiceLevelObjectiveBurnRateRuleService, "findBy")
+      .mockResolvedValue([
+        buildRule({
+          name: "Incident only",
+          shouldCreateAlert: false,
+          shouldCreateIncident: true,
+          incidentSeverity: "Sev2",
+        }),
+      ] as never);
+
+    const result: ToolExecutionResult = await QuerySlosTool.execute(
+      { sloId: SLO_ID.toString() },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("createsAlert=false");
+    expect(result.dataForLlm).toContain("createsIncident=true");
+    expect(result.dataForLlm).toContain("incidentSeverity=Sev2");
+  });
+
+  test("an incident rule with no severity relation loaded serializes without one instead of throwing", async () => {
+    jest
+      .spyOn(ServiceLevelObjectiveService, "findOneById")
+      .mockResolvedValue(buildSlo() as never);
+    jest
+      .spyOn(ServiceLevelObjectiveBurnRateRuleService, "findBy")
+      .mockResolvedValue([
+        buildRule({ name: "No severity", shouldCreateIncident: true }),
+      ] as never);
+
+    const result: ToolExecutionResult = await QuerySlosTool.execute(
+      { sloId: SLO_ID.toString() },
+      ctx,
+    );
+
+    // SLO row + the one rule row: the rule still made it through.
+    expect(result.rowCount).toBe(2);
+    expect(result.dataForLlm).toContain("createsIncident=true");
+    expect(result.dataForLlm).not.toContain("incidentSeverity=");
+  });
+
+  test("the tool description tells the model rules can declare incidents and where to follow them", () => {
+    const description: string = QuerySlosTool.description.toLowerCase();
+
+    // Without this the model never learns the incident half of a rule exists.
+    expect(description).toContain("incident");
+    expect(description).toContain("query_incidents");
+  });
+});
+
 describe("query_slos — list mode", () => {
   test("lists SLOs with target, window and persisted compliance", async () => {
     const findBySpy: jest.SpyInstance = jest