@oneuptime/common 12.0.4 → 12.0.6

package/Server/Services/AIInsightService.ts

@@ -8,7 +8,9 @@ import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import BadDataException from "../../Types/Exception/BadDataException";
-import AIInsightStatus from "../../Types/AI/AIInsightStatus";
+import AIInsightStatus, {
+  AIInsightStatusHelper,
+} from "../../Types/AI/AIInsightStatus";
 import AIInsightHumanVerdict from "../../Types/AI/AIInsightHumanVerdict";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
@@ -25,6 +27,18 @@ export class Service extends DatabaseService<AIInsight> {
     super(AIInsight);
   }
 
+  /*
+   * The open state an insight returns to when a human takes a terminal
+   * action back: FixOpened when an AI fix task was queued for it (that run
+   * is still the live thread of work), else ActionRequired — the same two
+   * states the scanner routes a freshly detected insight to.
+   */
+  private getReopenStatus(insight: AIInsight): AIInsightStatus {
+    return insight.fixAiRunId
+      ? AIInsightStatus.FixOpened
+      : AIInsightStatus.ActionRequired;
+  }
+
   /*
    * Human verdict capture — this IS the G11 precision measurement:
    * confirm/dismiss rates per insight type tell us how precise each
@@ -32,34 +46,123 @@ export class Service extends DatabaseService<AIInsight> {
    *
    * Overwriting an existing verdict is deliberate — people change their
    * minds; the latest verdict wins (per-insight state, not an audit trail).
-   * Dismissed is a human terminal state, so it also closes the insight;
-   * Confirmed leaves the status untouched (the insight stays open until a
-   * human resolves it or a fix lands).
+   * Dismissed is a human terminal state, so it also closes the insight.
+   *
+   * Confirmed normally leaves the status untouched (the insight stays open
+   * until a human resolves it or a fix lands) — with one exception: an
+   * insight closed AS Dismissed is closed on the grounds that it was noise,
+   * which a Confirmed verdict directly contradicts. Leaving it closed there
+   * produced the "Dismissed / Confirmed" pill pair with no way back, and
+   * kept the InsightStore dismissal cooldown suppressing the very finding
+   * the human just called real. So confirming a dismissed insight reopens
+   * it, which is also what makes Confirm a working undo for a misclick.
    *
    * Callers must have already access-checked the insight under the USER's
    * permissions — insight rows are server-authored (empty update ACL), so
-   * this writes as root.
+   * this reads and writes as root.
    */
   @CaptureSpan()
   public async applyHumanVerdict(data: {
     insightId: ObjectID;
     verdict: AIInsightHumanVerdict;
     byUserId: ObjectID;
-  }): Promise<{ insightId: ObjectID; verdict: AIInsightHumanVerdict }> {
-    await this.updateOneById({
+  }): Promise<{
+    insightId: ObjectID;
+    verdict: AIInsightHumanVerdict;
+    status: AIInsightStatus | null;
+  }> {
+    const insight: AIInsight | null = await this.findOneById({
       id: data.insightId,
+      select: { _id: true, status: true, fixAiRunId: true },
+      props: { isRoot: true },
+    });
+
+    if (!insight || !insight.id) {
+      throw new BadDataException("AI insight not found.");
+    }
+
+    let nextStatus: AIInsightStatus | null = null;
+
+    if (data.verdict === AIInsightHumanVerdict.Dismissed) {
+      nextStatus = AIInsightStatus.Dismissed;
+    } else if (insight.status === AIInsightStatus.Dismissed) {
+      nextStatus = this.getReopenStatus(insight);
+    }
+
+    await this.updateOneById({
+      id: insight.id,
       data: {
         humanVerdict: data.verdict,
         humanVerdictAt: OneUptimeDate.getCurrentDate(),
         humanVerdictByUserId: data.byUserId,
-        ...(data.verdict === AIInsightHumanVerdict.Dismissed
-          ? { status: AIInsightStatus.Dismissed }
-          : {}),
+        ...(nextStatus ? { status: nextStatus } : {}),
+      },
+      props: { isRoot: true },
+    });
+
+    return {
+      insightId: insight.id,
+      verdict: data.verdict,
+      status: nextStatus || insight.status || null,
+    };
+  }
+
+  /*
+   * Undo a terminal action: put a Resolved or Dismissed insight back into
+   * the open queue and drop the human verdict that closed it.
+   *
+   * Both terminal states are one click away from a full stop — a dismissal
+   * additionally suppresses the same fingerprint for the whole InsightStore
+   * cooldown, so a misclick silently blinds the project to that finding for
+   * days. Reopening is the way back: the status returns to the open state
+   * the scanner would have routed to, and the verdict is CLEARED rather
+   * than kept, because a verdict the human has taken back must not keep
+   * counting toward the per-detector precision measurement (and a stale
+   * humanVerdictAt would otherwise anchor a future cooldown).
+   *
+   * Idempotent: reopening an already-open insight is a no-op that reports
+   * the current status, so a double click (or two people clicking at once)
+   * cannot rewrite a status somebody else just set.
+   *
+   * Callers must have already access-checked the insight under the USER's
+   * permissions — this reads and writes as root.
+   */
+  @CaptureSpan()
+  public async reopenInsight(data: {
+    insightId: ObjectID;
+  }): Promise<{ insightId: ObjectID; status: AIInsightStatus }> {
+    const insight: AIInsight | null = await this.findOneById({
+      id: data.insightId,
+      select: { _id: true, status: true, fixAiRunId: true },
+      props: { isRoot: true },
+    });
+
+    if (!insight || !insight.id) {
+      throw new BadDataException("AI insight not found.");
+    }
+
+    if (
+      insight.status &&
+      !AIInsightStatusHelper.isTerminalStatus(insight.status)
+    ) {
+      return { insightId: insight.id, status: insight.status };
+    }
+
+    const status: AIInsightStatus = this.getReopenStatus(insight);
+
+    await this.updateOneById({
+      id: insight.id,
+      data: {
+        status: status,
+        // Explicit nulls — the columns are cleared, not left as they were.
+        humanVerdict: null as unknown as AIInsightHumanVerdict,
+        humanVerdictAt: null as unknown as Date,
+        humanVerdictByUserId: null as unknown as ObjectID,
       },
       props: { isRoot: true },
     });
 
-    return { insightId: data.insightId, verdict: data.verdict };
+    return { insightId: insight.id, status: status };
   }
 
   /*
@@ -79,7 +182,7 @@ export class Service extends DatabaseService<AIInsight> {
   }): Promise<{ insightId: ObjectID; status: AIInsightStatus }> {
     const insight: AIInsight | null = await this.findOneById({
       id: data.insightId,
-      select: { _id: true, humanVerdict: true },
+      select: { _id: true, humanVerdict: true, status: true },
       props: { isRoot: true },
     });
 
@@ -87,6 +190,23 @@ export class Service extends DatabaseService<AIInsight> {
       throw new BadDataException("AI insight not found.");
     }
 
+    /*
+     * Closing an already-closed insight is a no-op the caller should know
+     * about — and resolving a DISMISSED one is actively harmful: the store's
+     * re-file cooldown is keyed on the current terminal status, so the flip
+     * would silently trade a dismissal's 7-day quiet for a resolve's 24-hour
+     * one and let a finding a human called noise come back. The dashboard
+     * hides both actions on terminal insights; this closes the API path.
+     */
+    if (
+      insight.status &&
+      AIInsightStatusHelper.isTerminalStatus(insight.status)
+    ) {
+      throw new BadDataException(
+        `This AI insight is already ${insight.status.toLowerCase()} and cannot be resolved again.`,
+      );
+    }
+
     await this.updateOneById({
       id: insight.id,
       data: {

package/Server/Services/AIRunService.ts

@@ -3,12 +3,17 @@ import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
 import AIRunStatus from "../../Types/AI/AIRunStatus";
 import AIRunType from "../../Types/AI/AIRunType";
+import AIRunCodeFixRecommendation from "../../Types/AI/AIRunCodeFixRecommendation";
 import AIRunHumanVerdict from "../../Types/AI/AIRunHumanVerdict";
 import BadDataException from "../../Types/Exception/BadDataException";
 import CodeFixTaskType, {
   CodeFixContextKind,
   CodeFixTaskTypeHelper,
 } from "../../Types/AI/CodeFixTaskType";
+import {
+  getInvestigationCodeFixTaskSnapshot,
+  InvestigationCodeFixTaskContext,
+} from "../../Types/AI/CodeFixTaskContext";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import QueryHelper from "../Types/Database/QueryHelper";
 import CountBy from "../Types/Database/CountBy";
@@ -40,6 +45,7 @@ export interface AIRunTransitionSet {
   llmCallCount?: number | undefined;
   toolCallCount?: number | undefined;
   totalTokens?: number | undefined;
+  codeFixRecommendation?: AIRunCodeFixRecommendation | undefined;
   // The claiming agent's id as a string (ObjectID.toString()) — see above.
   aiAgentId?: string | undefined;
 }
@@ -52,8 +58,8 @@ export class Service extends DatabaseService<Model> {
   /*
    * A genuinely atomic status transition: one conditional UPDATE whose WHERE
    * carries the expected current status (and optionally the expected
-   * attemptCount). Returns the number of rows changed — 0 means another
-   * actor won the race.
+   * attemptCount / heartbeat snapshot). Returns the number of rows changed —
+   * 0 means another actor won the race or refreshed the heartbeat.
    *
    * This exists because updateOneBy is SELECT-then-save: two concurrent
    * callers can both observe the precondition and both write, so it cannot
@@ -65,6 +71,7 @@ export class Service extends DatabaseService<Model> {
     aiRunId: ObjectID;
     fromStatus: AIRunStatus;
     expectedAttemptCount?: number | undefined;
+    expectedLastHeartbeatAt?: Date | undefined;
     set: AIRunTransitionSet;
   }): Promise<number> {
     const queryBuilder: UpdateQueryBuilder<Model> = this.getRepository()
@@ -81,11 +88,91 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    if (data.expectedLastHeartbeatAt !== undefined) {
+      queryBuilder.andWhere('"lastHeartbeatAt" = :expectedLastHeartbeatAt', {
+        expectedLastHeartbeatAt: data.expectedLastHeartbeatAt,
+      });
+    }
+
     const result: UpdateResult = await queryBuilder.execute();
 
     return result.affected || 0;
   }
 
+  /*
+   * Persist the AI-written TL;DR of a completed investigation's analysis.
+   * Display-only, so this is a plain conditional UPDATE rather than a claim,
+   * but it is still write-once: scoped to the run, to the Completed state,
+   * and to a row that has no summary yet.
+   *
+   * The IS NULL guard is what makes the invariant structural rather than
+   * incidental. A stale attempt — one that lost the Completed CAS because the
+   * sweeper falsely requeued it — is kept out today only by statement order
+   * in the engine, and by then the WINNER has already written both the report
+   * and its summary, so a status-only guard would happily let the loser
+   * overwrite a summary that describes a different analysis. Returns the rows
+   * changed; 0 means the run moved on, was removed, or is already summarized.
+   */
+  @CaptureSpan()
+  public async setInvestigationAnalysisTldr(data: {
+    aiRunId: ObjectID;
+    analysisTldr: string;
+  }): Promise<number> {
+    const result: UpdateResult = await this.getRepository()
+      .createQueryBuilder()
+      .update(Model)
+      .set({
+        analysisTldr: data.analysisTldr,
+      } as QueryDeepPartialEntity<Model>)
+      .where('"_id" = :id', { id: data.aiRunId.toString() })
+      .andWhere('"status" = :status', { status: AIRunStatus.Completed })
+      .andWhere('"analysisTldr" IS NULL')
+      .andWhere('"deletedAt" IS NULL')
+      .execute();
+
+    return result.affected || 0;
+  }
+
+  /*
+   * Atomically settle the code-fix decision written as Pending by the
+   * winning investigation completion transition. The recommendation and
+   * immutable analysis snapshot are one database UPDATE guarded by both the
+   * run id and Pending state; a stale writer can never overwrite a decision
+   * another actor already settled.
+   */
+  @CaptureSpan()
+  public async finalizeInvestigationCodeFixRecommendation(
+    data:
+      | {
+          aiRunId: ObjectID;
+          recommendation: AIRunCodeFixRecommendation.Recommended;
+          taskContext: InvestigationCodeFixTaskContext;
+        }
+      | {
+          aiRunId: ObjectID;
+          recommendation: AIRunCodeFixRecommendation.NotRecommended;
+        },
+  ): Promise<number> {
+    const result: UpdateResult = await this.getRepository()
+      .createQueryBuilder()
+      .update(Model)
+      .set({
+        codeFixRecommendation: data.recommendation,
+        ...(data.recommendation === AIRunCodeFixRecommendation.Recommended
+          ? { taskContext: data.taskContext }
+          : {}),
+      } as QueryDeepPartialEntity<Model>)
+      .where('"_id" = :id', { id: data.aiRunId.toString() })
+      .andWhere('"status" = :status', { status: AIRunStatus.Completed })
+      .andWhere('"codeFixRecommendation" = :pending', {
+        pending: AIRunCodeFixRecommendation.Pending,
+      })
+      .andWhere('"deletedAt" IS NULL')
+      .execute();
+
+    return result.affected || 0;
+  }
+
   /*
    * Atomically claim the oldest Queued code-fix run for an external agent
    * worker (the /ai-agent-task/get-pending-task route). The Queued -> Running
@@ -193,10 +280,22 @@ export class Service extends DatabaseService<Model> {
           ? null
           : "Queued code-fix run has no telemetry exception to fix.";
       } else if (contextKind === CodeFixContextKind.IncidentOrAlertSubject) {
-        missingContextMessage =
-          run.triggeredByIncidentId || run.triggeredByAlertId
-            ? null
-            : "Queued code-fix run has no incident or alert subject.";
+        if (!run.triggeredByIncidentId && !run.triggeredByAlertId) {
+          missingContextMessage =
+            "Queued code-fix run has no incident or alert subject.";
+        } else if (
+          run.codeFixTaskType === CodeFixTaskType.FixFromIncident &&
+          !getInvestigationCodeFixTaskSnapshot(run.taskContext)
+        ) {
+          /*
+           * A subject alone is mutable context: a later investigation can post
+           * another RootCause before the worker starts. FixFromIncident must
+           * therefore carry the exact Recommended run + analysis it was
+           * authorized from. Contextless legacy rows fail closed.
+           */
+          missingContextMessage =
+            "Queued FixFromIncident run has no complete pinned investigation analysis snapshot.";
+        }
       } else if (
         run.codeFixTaskType === CodeFixTaskType.ImproveLogging ||
         run.codeFixTaskType === CodeFixTaskType.ImproveTracing
@@ -296,7 +395,7 @@ export class Service extends DatabaseService<Model> {
 
   /*
    * Measurement layer (Phase 2): record a human's one-click verdict
-   * (Confirmed / Rejected) on the LATEST COMPLETED investigation run for an
+   * (Confirmed / Rejected) on one exact COMPLETED investigation run for an
    * incident or alert. Overwriting an existing verdict is deliberate — a
    * user may change their mind; the verdict is per-run state, not an audit
    * trail. Throws when no completed investigation exists for the subject.
@@ -305,7 +404,9 @@ export class Service extends DatabaseService<Model> {
    * are system-authored, so the per-user privacy pin would hide them).
    */
   @CaptureSpan()
-  public async applyHumanVerdictToLatestInvestigation(data: {
+  public async applyHumanVerdictToInvestigation(data: {
+    aiRunId: ObjectID;
+    projectId: ObjectID;
     incidentId?: ObjectID | undefined;
     alertId?: ObjectID | undefined;
     verdict: AIRunHumanVerdict;
@@ -319,6 +420,8 @@ export class Service extends DatabaseService<Model> {
 
     const run: Model | null = await this.findOneBy({
       query: {
+        _id: data.aiRunId,
+        projectId: data.projectId,
         runType: AIRunType.Investigation,
         status: AIRunStatus.Completed,
         ...(data.incidentId
@@ -326,13 +429,12 @@ export class Service extends DatabaseService<Model> {
           : { triggeredByAlertId: data.alertId! }),
       },
       select: { _id: true },
-      sort: { createdAt: SortOrder.Descending },
       props: { isRoot: true },
     });
 
     if (!run || !run.id) {
       throw new BadDataException(
-        "No completed AI investigation exists for this subject yet — a verdict can only be recorded on a completed investigation.",
+        "The selected completed AI investigation does not exist for this subject — refresh the page before recording a verdict.",
       );
     }
 

package/Server/Services/AIService.ts

@@ -88,6 +88,15 @@ export const AI_INVESTIGATION_GRADING_FEATURE: string =
 export const AI_CONFIDENCE_CLASSIFICATION_FEATURE: string =
   "AI Confidence Classification";
 
+/*
+ * The LlmLog feature name for the investigation TL;DR (InvestigationTldr) —
+ * one constrained call per completed investigation that has an analysis,
+ * outside the per-run caps but inside this daily budget. A budget rejection
+ * (or any other failure) simply leaves the run without a TL;DR; the report
+ * is still published and the panel omits the block.
+ */
+export const AI_INVESTIGATION_TLDR_FEATURE: string = "AI Investigation TLDR";
+
 /*
  * The LlmLog feature name for server-mediated code-fix agent completions
  * (B4 Tier 0) — the in-house coding agent's tool loop routes every LLM call
@@ -155,19 +164,32 @@ export const AI_REMEDIATION_EXECUTION_FEATURE: string =
  * (SQL `= ANY`, and an `.includes()` gate on the write path that no writer can
  * trip because no writer emits these strings any more).
  */
+const LEGACY_SENTINEL_INCIDENT_INVESTIGATION_FEATURE: string =
+  "Sentinel Incident Investigation";
+const LEGACY_SENTINEL_ALERT_INVESTIGATION_FEATURE: string =
+  "Sentinel Alert Investigation";
+const LEGACY_SENTINEL_INVESTIGATION_GRADING_FEATURE: string =
+  "Sentinel Investigation Grading";
+const LEGACY_SENTINEL_CONFIDENCE_CLASSIFICATION_FEATURE: string =
+  "Sentinel Confidence Classification";
+const LEGACY_SENTINEL_CODE_FIX_FEATURE: string = "Sentinel Code Fix";
+const LEGACY_SENTINEL_INSIGHT_TRIAGE_FEATURE: string =
+  "Sentinel Insight Triage";
+
 export const LEGACY_AUTONOMOUS_AI_FEATURES: Array<string> = [
-  "Sentinel Incident Investigation",
-  "Sentinel Alert Investigation",
-  "Sentinel Investigation Grading",
-  "Sentinel Confidence Classification",
-  "Sentinel Code Fix",
-  "Sentinel Insight Triage",
+  LEGACY_SENTINEL_INCIDENT_INVESTIGATION_FEATURE,
+  LEGACY_SENTINEL_ALERT_INVESTIGATION_FEATURE,
+  LEGACY_SENTINEL_INVESTIGATION_GRADING_FEATURE,
+  LEGACY_SENTINEL_CONFIDENCE_CLASSIFICATION_FEATURE,
+  LEGACY_SENTINEL_CODE_FIX_FEATURE,
+  LEGACY_SENTINEL_INSIGHT_TRIAGE_FEATURE,
 ];
 
 /*
- * Features that run WITHOUT a human in the loop. The per-project daily token
- * budget (Project.aiDailyAutonomousTokenLimit, G4) applies only to these —
- * interactive chat and explicitly user-triggered AI are never budget-blocked.
+ * Features that run WITHOUT a human in the loop. Incident-linked and
+ * alert-linked calls use their respective daily token limits; subjectless
+ * calls use Project.aiDailyAutonomousTokenLimit. Interactive chat and
+ * explicitly user-triggered AI are never budget-blocked.
  * Auto-postmortem is deliberately excluded for now: it is one call per
  * resolved incident, not storm-shaped; include it when it moves to the queue.
  *
@@ -183,12 +205,18 @@ export const AUTONOMOUS_AI_FEATURES: Array<string> = [
   AI_INVESTIGATION_GRADING_FEATURE,
   // One constrained call per completed investigation (ConfidenceSignal).
   AI_CONFIDENCE_CLASSIFICATION_FEATURE,
+  /*
+   * One constrained call per completed investigation that produced an
+   * analysis (InvestigationTldr) — same storm shape as the classification
+   * above, so the same daily budget must cover it.
+   */
+  AI_INVESTIGATION_TLDR_FEATURE,
   /*
    * Server-mediated code-fix agent completions (B4 Tier 0). Fix runs are
    * user-triggered, but the tool loop then runs unattended for up to ~40
    * calls — storm-shaped enough that the daily budget must cover it. The
    * per-run loop budgets (CodeFixAgentCompletion) cap a single run; this
-   * daily pool caps all of them together.
+   * daily subject lane caps all of them together.
    */
   AI_CODE_FIX_FEATURE,
   /*
@@ -215,7 +243,7 @@ export const AUTONOMOUS_AI_FEATURES: Array<string> = [
   /*
    * Auto-remediation command composition/execution
    * (RemediationExecutionRunner). Same trigger shape as planning, with a
-   * larger per-run tool budget — the daily pool must cover it.
+   * larger per-run tool budget — the daily subject lane must cover it.
    */
   AI_REMEDIATION_EXECUTION_FEATURE,
   /*
@@ -226,6 +254,23 @@ export const AUTONOMOUS_AI_FEATURES: Array<string> = [
   ...LEGACY_AUTONOMOUS_AI_FEATURES,
 ];
 
+/*
+ * Before subject-lane accounting shipped, the main investigation calls did
+ * not persist incidentId/alertId (or aiRunId). Their feature label is the only
+ * durable lane signal left on those rows. Keep these lists so a deployment
+ * does not reset today's incident/alert spend or charge it to background work.
+ */
+const LEGACY_INCIDENT_LANE_FEATURES: Array<string> = [
+  AI_INCIDENT_INVESTIGATION_FEATURE,
+  AI_INVESTIGATION_GRADING_FEATURE,
+  LEGACY_SENTINEL_INCIDENT_INVESTIGATION_FEATURE,
+  LEGACY_SENTINEL_INVESTIGATION_GRADING_FEATURE,
+];
+const LEGACY_ALERT_LANE_FEATURES: Array<string> = [
+  AI_ALERT_INVESTIGATION_FEATURE,
+  LEGACY_SENTINEL_ALERT_INVESTIGATION_FEATURE,
+];
+
 export interface AutonomousBudgetStatus {
   exhausted: boolean;
   // null when the project has no limit configured.
@@ -237,10 +282,10 @@ export interface AILogRequest {
   projectId: ObjectID;
   userId?: ObjectID | undefined;
   feature: string; // e.g., "IncidentPostmortem", "IncidentNote"
-  incidentId?: ObjectID;
-  alertId?: ObjectID;
-  scheduledMaintenanceId?: ObjectID;
-  aiRunId?: ObjectID;
+  incidentId?: ObjectID | undefined;
+  alertId?: ObjectID | undefined;
+  scheduledMaintenanceId?: ObjectID | undefined;
+  aiRunId?: ObjectID | undefined;
   /*
    * When set, use this specific provider (validated against the project) rather
    * than the project default. Powers the in-chat provider/model switcher.
@@ -337,23 +382,40 @@ export class Service extends BaseService {
   }
 
   /*
-   * G4 daily budget: has this project consumed its daily autonomous-token
-   * allowance (UTC day)? Counts only AUTONOMOUS_AI_FEATURES tokens, so chat
-   * usage neither eats the autonomous budget nor is blocked by it.
+   * G4 daily budget: has this project consumed the selected subject lane's
+   * daily autonomous-token allowance (UTC day)? Counts only that lane's
+   * AUTONOMOUS_AI_FEATURES tokens, so chat usage neither eats the autonomous
+   * budget nor is blocked by it.
    */
   @CaptureSpan()
   public async getAutonomousDailyBudgetStatus(
     projectId: ObjectID,
+    subject?: {
+      incidentId?: ObjectID | undefined;
+      alertId?: ObjectID | undefined;
+    },
   ): Promise<AutonomousBudgetStatus> {
+    this.assertSingleSubject(subject);
+
     const project: Project | null = await ProjectService.findOneById({
       id: projectId,
-      select: { aiDailyAutonomousTokenLimit: true },
+      select: {
+        aiDailyAutonomousTokenLimit: true,
+        incidentAiDailyAutonomousTokenLimit: true,
+        alertAiDailyAutonomousTokenLimit: true,
+      },
       props: { isRoot: true },
     });
 
-    const limitInTokens: number | null =
+    let limitInTokens: number | null =
       project?.aiDailyAutonomousTokenLimit ?? null;
 
+    if (subject?.incidentId) {
+      limitInTokens = project?.incidentAiDailyAutonomousTokenLimit ?? null;
+    } else if (subject?.alertId) {
+      limitInTokens = project?.alertAiDailyAutonomousTokenLimit ?? null;
+    }
+
     if (limitInTokens === null) {
       return { exhausted: false, limitInTokens: null, usedTokensToday: 0 };
     }
@@ -374,6 +436,10 @@ export class Service extends BaseService {
           "UTC",
         ),
         features: AUTONOMOUS_AI_FEATURES,
+        incidentId: subject?.incidentId,
+        alertId: subject?.alertId,
+        legacyIncidentFeatures: LEGACY_INCIDENT_LANE_FEATURES,
+        legacyAlertFeatures: LEGACY_ALERT_LANE_FEATURES,
       },
     );
 
@@ -388,6 +454,8 @@ export class Service extends BaseService {
   public async executeWithLogging(
     request: AILogRequest,
   ): Promise<AILogResponse> {
+    this.assertSingleSubject(request);
+
     const startTime: Date = new Date();
 
     // Get LLM provider for the project (honoring an explicit per-chat choice).
@@ -503,10 +571,18 @@ export class Service extends BaseService {
      */
     if (AUTONOMOUS_AI_FEATURES.includes(request.feature)) {
       const budget: AutonomousBudgetStatus =
-        await this.getAutonomousDailyBudgetStatus(request.projectId);
+        await this.getAutonomousDailyBudgetStatus(request.projectId, {
+          incidentId: request.incidentId,
+          alertId: request.alertId,
+        });
 
       if (budget.exhausted) {
-        const budgetMessage: string = `Daily autonomous AI token budget exhausted (${budget.usedTokensToday.toLocaleString()} of ${budget.limitInTokens?.toLocaleString()} tokens used today). Autonomous AI requests resume tomorrow (UTC) — raise or unset the limit in the AI settings pages.`;
+        const settingsLocation: string = request.incidentId
+          ? "Incidents > AI > Investigation"
+          : request.alertId
+            ? "Alerts > AI > Investigation"
+            : "Project Settings > AI > AI Guardrails";
+        const budgetMessage: string = `Daily autonomous AI token budget exhausted (${budget.usedTokensToday.toLocaleString()} of ${budget.limitInTokens?.toLocaleString()} tokens used today). Autonomous AI requests resume tomorrow (UTC) — raise or unset the limit under ${settingsLocation}.`;
 
         logEntry.status = LlmLogStatus.BudgetExceeded;
         logEntry.statusMessage = budgetMessage.substring(0, 490);
@@ -658,6 +734,17 @@ export class Service extends BaseService {
     }
   }
 
+  private assertSingleSubject(subject?: {
+    incidentId?: ObjectID | undefined;
+    alertId?: ObjectID | undefined;
+  }): void {
+    if (subject?.incidentId && subject.alertId) {
+      throw new BadDataException(
+        "An AI request cannot belong to both an incident and an alert.",
+      );
+    }
+  }
+
   /*
    * Set gen_ai.* attributes (OpenTelemetry GenAI semantic conventions) on the
    * currently-active span. The @CaptureSpan()-wrapped caller owns that span, so

package/Server/Services/AlertFeedService.ts

@@ -84,6 +84,7 @@ export class Service extends DatabaseService<Model> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
+    aiRunId?: ObjectID | undefined;
     workspaceNotification?:
       | {
           notifyUserId?: ObjectID | undefined; // this is oneuptime user id.
@@ -126,6 +127,10 @@ export class Service extends DatabaseService<Model> {
       alertFeed.alertFeedEventType = data.alertFeedEventType;
       alertFeed.projectId = data.projectId;
 
+      if (data.aiRunId) {
+        alertFeed.aiRunId = data.aiRunId;
+      }
+
       if (!data.postedAt) {
         alertFeed.postedAt = OneUptimeDate.getCurrentDate();
       }