@oneuptime/common 11.5.11 → 11.5.13

package/Server/Utils/AI/SRE/Insights/InsightScanner.ts

@@ -11,6 +11,12 @@ import InsightStore, { UpsertCandidatesResult } from "./InsightStore";
 import InsightFixRouting, { InsightFixRoutingResult } from "./FixRouting";
 import InsightTriage, { InsightTriageResult } from "./Triage";
 import { InsightCandidate, InsightDetector, InsightScanContext } from "./Types";
+import AIInsightType from "../../../../../Types/AI/AIInsightType";
+import AIRunType from "../../../../../Types/AI/AIRunType";
+import AIRunStatus from "../../../../../Types/AI/AIRunStatus";
+import ExceptionAIClassification from "../../../../../Types/AI/ExceptionAIClassification";
+import AIRunService from "../../../../Services/AIRunService";
+import QueryHelper from "../../../../Types/Database/QueryHelper";
 import logger from "../../../Logger";
 import CaptureSpan from "../../../Telemetry/CaptureSpan";
 
@@ -19,8 +25,9 @@ import CaptureSpan from "../../../Telemetry/CaptureSpan";
  *
  * THE RULE: no LLM here. Detectors are deterministic statistical sensors;
  * the LLM only engages per-finding AFTERWARDS through InsightTriage
- * (budgeted, read-only), and the fix decision inside InsightFixRouting is
- * deterministic and reuses the existing budgeted CodeFix creation paths.
+ * (budgeted, read-only). The automatic fix decision happens after triage
+ * completes (InsightTriageRunner → InsightFixRouting) and only for
+ * insights the triage classified as code faults.
  *
  * Everything is opt-in and quiet: only projects with the default-false
  * enableAiInsights flag are scanned, insights never page and never
@@ -73,8 +80,8 @@ export default class InsightScanner {
    * One project's scan: self-heal any insight an earlier tick left unrouted,
    * run every registered detector (isolated — one failing sensor must not
    * blind the others), dedupe/upsert the candidates through InsightStore,
-   * then route each NEWLY created insight to FixOpened or ActionRequired and
-   * enqueue its triage.
+   * then route each NEWLY created insight to ActionRequired and enqueue its
+   * triage (which, on a code-fault verdict, routes the fix).
    */
   @CaptureSpan()
   public static async scanProjectForInsights(project: Project): Promise<void> {
@@ -211,19 +218,200 @@ export default class InsightScanner {
         );
       }
     }
+
+    await this.resweepUntriagedInsights({ projectId });
+    await this.resweepUnroutedCodeFaults({ projectId, project });
+  }
+
+  /*
+   * Stranded shape 2: ActionRequired insights that never got a triage
+   * verdict. With triage gating the automatic fix, a triage that was
+   * quiet-skipped (token budget exhausted), expired in the queue, or
+   * failed would otherwise strand the insight verdict-less FOREVER — and
+   * with it any automatic fix. Re-enqueueing is safe and cheap: the
+   * triage enqueue dedupes to one non-terminal run per insight and
+   * quiet-skips when the budget still has no headroom. Bounded two ways:
+   * only insights from the last 7 days (older rows predate the verdict
+   * gate or were consciously left alone), and only while fewer than 3
+   * triage attempts have ended in failure (a permanently failing triage
+   * must not retry every 15 minutes for a week).
+   */
+  private static async resweepUntriagedInsights(data: {
+    projectId: ObjectID;
+  }): Promise<void> {
+    const { projectId } = data;
+
+    try {
+      const untriaged: Array<AIInsight> = await AIInsightService.findBy({
+        query: {
+          projectId: projectId,
+          status: AIInsightStatus.ActionRequired,
+          triageCompletedAt: QueryHelper.isNull(),
+          createdAt: QueryHelper.greaterThanEqualTo(
+            OneUptimeDate.addRemoveDays(OneUptimeDate.getCurrentDate(), -7),
+          ),
+        },
+        select: {
+          _id: true,
+          projectId: true,
+          insightType: true,
+          serviceName: true,
+          traceId: true,
+          telemetryExceptionId: true,
+          evidence: true,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: { isRoot: true },
+      });
+
+      for (const insight of untriaged) {
+        try {
+          const failedTriageAttempts: number = (
+            await AIRunService.countBy({
+              query: {
+                runType: AIRunType.Investigation,
+                triggeredByAiInsightId: insight.id!,
+                status: QueryHelper.any([
+                  AIRunStatus.Error,
+                  AIRunStatus.Cancelled,
+                  AIRunStatus.Stale,
+                ]),
+              },
+              props: { isRoot: true },
+            })
+          ).toNumber();
+
+          if (failedTriageAttempts >= 3) {
+            continue;
+          }
+
+          const triageResult: InsightTriageResult =
+            await InsightTriage.enqueueInsightTriage({ insight: insight });
+
+          if (triageResult.triageAiRunId) {
+            await AIInsightService.updateOneById({
+              id: insight.id!,
+              data: {
+                triageAiRunId: triageResult.triageAiRunId,
+              },
+              props: { isRoot: true },
+            });
+          }
+        } catch (error) {
+          logger.error(
+            `AI Insights: triage re-enqueue failed for insight ${insight.id?.toString()} — continuing: ${error}`,
+          );
+        }
+      }
+    } catch (error) {
+      logger.error(
+        `AI Insights: failed to sweep untriaged insights for project ${projectId.toString()} — continuing with the scan: ${error}`,
+      );
+    }
+  }
+
+  /*
+   * Stranded shape 3: a code-fault verdict was recorded but the fix was
+   * never routed — the pod died between the verdict write and the fix
+   * routing, or routing quiet-skipped on a transient gate (daily fix
+   * budget, readiness). Re-routing is idempotent: the creation path's
+   * per-(exception, recipe) dedupe and the cross-group guard refuse
+   * duplicates, and the conditional status flip only moves
+   * ActionRequired → FixOpened. Bounded to verdicts from the last 24
+   * hours so a permanently refused group (declined by a human, capped
+   * repo) does not retry forever. Latency insights are excluded — they
+   * are fix-routed deterministically at scan time.
+   */
+  private static async resweepUnroutedCodeFaults(data: {
+    projectId: ObjectID;
+    project: Project;
+  }): Promise<void> {
+    const { projectId, project } = data;
+
+    try {
+      const unrouted: Array<AIInsight> = await AIInsightService.findBy({
+        query: {
+          projectId: projectId,
+          status: AIInsightStatus.ActionRequired,
+          classification: ExceptionAIClassification.CodeFault,
+          fixAiRunId: QueryHelper.isNull(),
+          triageCompletedAt: QueryHelper.greaterThanEqualTo(
+            OneUptimeDate.addRemoveDays(OneUptimeDate.getCurrentDate(), -1),
+          ),
+        },
+        select: {
+          _id: true,
+          projectId: true,
+          insightType: true,
+          serviceName: true,
+          traceId: true,
+          telemetryExceptionId: true,
+          evidence: true,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: { isRoot: true },
+      });
+
+      for (const insight of unrouted) {
+        if (insight.insightType === AIInsightType.TraceLatencyRegression) {
+          continue;
+        }
+
+        try {
+          const fixResult: InsightFixRoutingResult =
+            await InsightFixRouting.routeInsightFix({
+              insight: insight,
+              project: project,
+            });
+
+          if (fixResult.fixAiRunId) {
+            await AIInsightService.updateOneBy({
+              query: {
+                _id: insight.id!.toString(),
+                status: AIInsightStatus.ActionRequired,
+              },
+              data: {
+                status: AIInsightStatus.FixOpened,
+                fixAiRunId: fixResult.fixAiRunId,
+              },
+              props: { isRoot: true },
+            });
+          }
+        } catch (error) {
+          logger.error(
+            `AI Insights: fix re-routing failed for insight ${insight.id?.toString()} — continuing: ${error}`,
+          );
+        }
+      }
+    } catch (error) {
+      logger.error(
+        `AI Insights: failed to sweep unrouted code-fault insights for project ${projectId.toString()} — continuing with the scan: ${error}`,
+      );
+    }
   }
 
   /*
    * Route one insight — newly created this tick, or swept up as stranded
-   * from an earlier one — out of the defensive Detected state:
-   *   1. deterministic fix routing (gated on enableAi + enableInsightFixTasks
-   *      inside InsightFixRouting) → FixOpened + fixAiRunId, else
-   *      ActionRequired;
-   *   2. triage enqueue for EVERY new insight — triage enriches fix and
-   *      non-fix insights alike → triageAiRunId when a run was enqueued.
-   * Both collaborators are never-throws by contract, but they are wrapped
-   * anyway: a contract breach must degrade (no fix / no triage), not leave
-   * the insight stuck in Detected or fail the scan.
+   * from an earlier one — out of the defensive Detected state.
+   *
+   * TRIAGE GATES THE FIX. The automatic fix decision no longer happens
+   * here: every new insight goes to ActionRequired and gets its triage
+   * enqueued; when the triage run completes with a code-fault
+   * classification, InsightTriageRunner routes the fix (via
+   * InsightFixRouting) and flips the insight to FixOpened. This exists
+   * because roughly half of real exception insights turn out to be
+   * expected user errors or intentional denials (auth, paywalls, scanner
+   * probes) — opening an unreviewed fix PR for those is worse than
+   * opening none: the agent's only "fix" is to weaken the check that
+   * correctly fired. Fail-closed by design: no triage verdict, no
+   * automatic PR. The manual "Fix with AI" button on the exception page
+   * is unaffected.
+   *
+   * The collaborator is never-throws by contract, but it is wrapped
+   * anyway: a contract breach must degrade (no triage), not leave the
+   * insight stuck in Detected or fail the scan.
    */
   private static async routeNewInsight(data: {
     insight: AIInsight;
@@ -231,19 +419,29 @@ export default class InsightScanner {
   }): Promise<void> {
     const { insight, project } = data;
 
+    /*
+     * TraceLatencyRegression keeps DETERMINISTIC scan-time fix routing:
+     * its evidence is the SpanTreeAnalyzer's own findings (N+1, dominant
+     * span, sequential fan-out) — no LLM verdict adds signal there, and
+     * the exception-centric classification taxonomy would mislabel most
+     * latency regressions as "infrastructure". Exception insights go
+     * through the verdict gate instead.
+     */
     let fixAiRunId: ObjectID | undefined = undefined;
 
-    try {
-      const fixResult: InsightFixRoutingResult =
-        await InsightFixRouting.routeInsightFix({
-          insight: insight,
-          project: project,
-        });
-      fixAiRunId = fixResult.fixAiRunId;
-    } catch (error) {
-      logger.error(
-        `AI Insights: fix routing threw for insight ${insight.id?.toString()} (treating as no fix opened): ${error}`,
-      );
+    if (insight.insightType === AIInsightType.TraceLatencyRegression) {
+      try {
+        const fixResult: InsightFixRoutingResult =
+          await InsightFixRouting.routeInsightFix({
+            insight: insight,
+            project: project,
+          });
+        fixAiRunId = fixResult.fixAiRunId;
+      } catch (error) {
+        logger.error(
+          `AI Insights: fix routing threw for latency insight ${insight.id?.toString()} (treating as no fix opened): ${error}`,
+        );
+      }
     }
 
     if (fixAiRunId) {

package/Server/Utils/AI/SRE/Insights/InsightTriageRunner.ts

@@ -1,13 +1,23 @@
 import ObjectID from "../../../../../Types/ObjectID";
 import OneUptimeDate from "../../../../../Types/Date";
 import AIInsight from "../../../../../Models/DatabaseModels/AIInsight";
+import Project from "../../../../../Models/DatabaseModels/Project";
 import AIInsightEvidence from "../../../../../Types/AI/AIInsightEvidence";
+import AIInsightStatus, {
+  AIInsightStatusHelper,
+} from "../../../../../Types/AI/AIInsightStatus";
+import AIInsightType from "../../../../../Types/AI/AIInsightType";
+import ExceptionAIClassification from "../../../../../Types/AI/ExceptionAIClassification";
 import AIInsightService from "../../../../Services/AIInsightService";
+import ProjectService from "../../../../Services/ProjectService";
+import TelemetryExceptionService from "../../../../Services/TelemetryExceptionService";
 import { AI_INSIGHT_TRIAGE_FEATURE } from "../../../../Services/AIService";
 import AIInvestigationEngine from "../AIInvestigationEngine";
 import AIInvestigationQueue from "../InvestigationQueue";
+import InsightFixRouting, { InsightFixRoutingResult } from "./FixRouting";
 import { ConfidenceSignal } from "../ConfidenceSignal";
 import { ObservabilityAssistantResult } from "../../Chat/ObservabilityAssistant";
+import ToolResultSerializer from "../../Toolbox/Serializer";
 import logger from "../../../Logger";
 import CaptureSpan from "../../../Telemetry/CaptureSpan";
 
@@ -44,7 +54,17 @@ const PREVENTIVE_TRIAGE_FRAMING: string = `IMPORTANT — this is PREVENTIVE TRIA
 - Establish the most likely root cause of the finding.
 - Estimate the blast radius: which services/users/operations are affected, and how badly.
 - Recommend exactly ONE next action (the single most useful thing an engineer should do first).
-Cite the evidence for every factual claim. If the telemetry cannot support a conclusion, say so plainly. Do not refer to "the incident" — there is none.`;
+Cite the evidence for every factual claim. If the telemetry cannot support a conclusion, say so plainly. Do not refer to "the incident" — there is none.
+
+CLASSIFICATION — you MUST end your analysis with one line in EXACTLY this format, on its own line, with nothing after it:
+Classification: <verdict>
+where <verdict> is exactly one of: code-fault, user-error, expected-denial, infrastructure, unknown.
+- code-fault: a defect in the monitored code that a code change should fix.
+- user-error: an expected consequence of invalid end-user input (bad parameters, malformed values, garbage in a URL). The code rejected it correctly; the input was wrong.
+- expected-denial: an intentional check doing its job — authentication/authorization failures, plan or paywall rejections, rate limits, or security scanners/fuzzers tripping validation on purpose-built probes.
+- infrastructure: an environmental condition (network timeout, connection reset, resource exhaustion, dependency outage) rather than a logic defect.
+- unknown: the evidence does not support a confident verdict.
+This verdict gates automation: ONLY code-fault findings may get an automatic fix pull request, so classify conservatively — when torn between code-fault and anything else, pick the other one.`;
 
 export default class InsightTriageRunner {
   /*
@@ -63,11 +83,13 @@ export default class InsightTriageRunner {
     const { aiRunId, projectId, sentinelInsightId, attemptCount } = data;
 
     let contextSummary: string;
+    let insight: AIInsight | null = null;
     try {
-      const insight: AIInsight | null = await AIInsightService.findOneById({
+      insight = await AIInsightService.findOneById({
         id: sentinelInsightId,
         select: {
           _id: true,
+          projectId: true,
           insightType: true,
           severity: true,
           title: true,
@@ -75,6 +97,7 @@ export default class InsightTriageRunner {
           evidence: true,
           serviceName: true,
           traceId: true,
+          telemetryExceptionId: true,
           metricName: true,
           firstSeenAt: true,
           lastSeenAt: true,
@@ -118,30 +141,217 @@ export default class InsightTriageRunner {
           confidence: ConfidenceSignal;
           result: ObservabilityAssistantResult;
         }): Promise<void> => {
+          const classification: ExceptionAIClassification =
+            this.parseClassification(postData.analysisMarkdown);
+
           /*
-           * The quiet inbox — deliberately the ONLY write: no feed items,
-           * no workspace notification, no owner/on-call ping, no metrics,
-           * and no instrumentation-task trigger. Insights never page and
-           * never enter the notification pipeline (Preventive-lane rule);
-           * the summary waits on the Insights page until a human looks.
+           * The quiet inbox — the summary and verdict land on the insight
+           * row: no feed items, no workspace notification, no owner/on-call
+           * ping, no metrics, and no instrumentation-task trigger. Insights
+           * never page and never enter the notification pipeline
+           * (Preventive-lane rule); the summary waits on the Insights page
+           * until a human looks.
            */
           await AIInsightService.updateOneById({
             id: sentinelInsightId,
             data: {
               triageSummaryMarkdown: postData.analysisMarkdown,
               triageCompletedAt: OneUptimeDate.getCurrentDate(),
+              classification: classification,
             },
             props: { isRoot: true },
           });
 
           logger.debug(
-            `AI insights: triage summary posted for insight ${sentinelInsightId.toString()} (run ${aiRunId.toString()}, confident=${postData.confidence.confident} via ${postData.confidence.source}).`,
+            `AI insights: triage summary posted for insight ${sentinelInsightId.toString()} (run ${aiRunId.toString()}, classification=${classification}, confident=${postData.confidence.confident} via ${postData.confidence.source}).`,
           );
+
+          /*
+           * Verdict-driven follow-through. Best-effort by design: the
+           * triage summary is already posted, and a failure here must not
+           * fail the triage run itself.
+           */
+          try {
+            await this.actOnClassification({
+              insight: insight!,
+              classification: classification,
+            });
+          } catch (error) {
+            logger.error(
+              `AI insights: post-triage action failed for insight ${sentinelInsightId.toString()} (verdict ${classification}): ${error}`,
+            );
+          }
         },
       },
     });
   }
 
+  /*
+   * Parse the mandatory trailing "Classification: <verdict>" line out of
+   * the triage analysis. The LAST match wins (the model may discuss the
+   * taxonomy earlier in its reasoning). Anything unparseable is Unknown —
+   * and Unknown never routes a fix, so a malformed answer fails closed.
+   */
+  public static parseClassification(
+    analysisMarkdown: string,
+  ): ExceptionAIClassification {
+    const matches: Array<RegExpMatchArray> = Array.from(
+      (analysisMarkdown || "").matchAll(
+        /^\s*\**\s*classification\s*\**\s*[:=]\s*\**\s*(code-fault|user-error|expected-denial|infrastructure|unknown)\b/gim,
+      ),
+    );
+
+    const last: RegExpMatchArray | undefined = matches[matches.length - 1];
+
+    if (!last || !last[1]) {
+      return ExceptionAIClassification.Unknown;
+    }
+
+    return last[1].toLowerCase() as ExceptionAIClassification;
+  }
+
+  /*
+   * Act on the triage verdict:
+   *
+   * 1. Stamp the verdict onto the exception group row (aiClassification)
+   *    so the exceptions list can filter on it and the fix lane can skip
+   *    known-non-defects without re-triaging.
+   * 2. code-fault → route the automatic fix (InsightFixRouting owns every
+   *    gate: enableAi, enableInsightFixTasks, budget, readiness, dedupe)
+   *    and flip the insight to FixOpened when a run was queued.
+   * 3. expected-denial → optionally auto-archive the exception group when
+   *    the project opted in (autoArchiveNonActionableExceptions). Only
+   *    expected denials are archived — user errors and infrastructure
+   *    conditions stay visible for a human to judge.
+   */
+  private static async actOnClassification(data: {
+    insight: AIInsight;
+    classification: ExceptionAIClassification;
+  }): Promise<void> {
+    const { insight, classification } = data;
+
+    if (!insight.id || !insight.projectId) {
+      return;
+    }
+
+    /*
+     * The verdict stamp on the exception group is metadata and always
+     * lands; the AUTOMATION below (fix PR, auto-archive) additionally
+     * requires that no human closed the insight while the triage run sat
+     * in the queue or executed. The `insight` object is a snapshot from
+     * claim time — minutes to half an hour old — so the status MUST be
+     * re-read here: an insight a human Dismissed or Resolved in the
+     * meantime gets no PR and keeps its terminal status.
+     */
+    if (insight.telemetryExceptionId) {
+      await TelemetryExceptionService.updateOneById({
+        id: insight.telemetryExceptionId,
+        data: {
+          aiClassification: classification,
+        },
+        props: { isRoot: true },
+      });
+    }
+
+    const currentInsight: AIInsight | null = await AIInsightService.findOneById(
+      {
+        id: insight.id,
+        select: {
+          _id: true,
+          status: true,
+        },
+        props: { isRoot: true },
+      },
+    );
+
+    if (
+      !currentInsight ||
+      (currentInsight.status &&
+        AIInsightStatusHelper.isTerminalStatus(currentInsight.status))
+    ) {
+      logger.debug(
+        `AI insights: skipping post-triage automation for insight ${insight.id.toString()} — insight is ${currentInsight?.status || "deleted"}.`,
+      );
+      return;
+    }
+
+    const project: Project | null = await ProjectService.findOneById({
+      id: insight.projectId,
+      select: {
+        _id: true,
+        enableAi: true,
+        enableInsightFixTasks: true,
+        autoArchiveNonActionableExceptions: true,
+      },
+      props: { isRoot: true },
+    });
+
+    if (!project) {
+      return;
+    }
+
+    /*
+     * TraceLatencyRegression insights are fix-routed DETERMINISTICALLY at
+     * scan time (their span-tree evidence needs no LLM verdict — see
+     * InsightScanner.routeNewInsight); routing them again here would
+     * duplicate the run/PR. The verdict gate applies to exception
+     * insights only.
+     */
+    const isVerdictGatedInsight: boolean =
+      insight.insightType !== AIInsightType.TraceLatencyRegression;
+
+    if (
+      classification === ExceptionAIClassification.CodeFault &&
+      isVerdictGatedInsight
+    ) {
+      const fixResult: InsightFixRoutingResult =
+        await InsightFixRouting.routeInsightFix({
+          insight: insight,
+          project: project,
+        });
+
+      if (fixResult.fixAiRunId) {
+        /*
+         * Conditional flip: only a still-ActionRequired insight moves to
+         * FixOpened, so a dismissal landing between the status re-read
+         * above and this write can never be clobbered.
+         */
+        await AIInsightService.updateOneBy({
+          query: {
+            _id: insight.id.toString(),
+            status: AIInsightStatus.ActionRequired,
+          },
+          data: {
+            status: AIInsightStatus.FixOpened,
+            fixAiRunId: fixResult.fixAiRunId,
+          },
+          props: { isRoot: true },
+        });
+      }
+
+      return;
+    }
+
+    if (
+      classification === ExceptionAIClassification.ExpectedDenial &&
+      project.autoArchiveNonActionableExceptions === true &&
+      insight.telemetryExceptionId
+    ) {
+      await TelemetryExceptionService.updateOneById({
+        id: insight.telemetryExceptionId,
+        data: {
+          isArchived: true,
+          markedAsArchivedAt: OneUptimeDate.getCurrentDate(),
+        },
+        props: { isRoot: true },
+      });
+
+      logger.debug(
+        `AI insights: auto-archived exception ${insight.telemetryExceptionId.toString()} (expected-denial verdict, project opted in).`,
+      );
+    }
+  }
+
   // Build the compact insight record that seeds the triage.
   private static buildInsightSummary(insight: AIInsight): string {
     const lines: Array<string> = [];
@@ -191,7 +401,13 @@ export default class InsightTriageRunner {
       lines.push(renderedEvidence);
     }
 
-    return lines.join("\n");
+    /*
+     * Detector detailMarkdown and evidence quote raw exception messages —
+     * sweep secrets/PII before the text reaches the LLM provider. (The
+     * chat/investigation toolbox path already redacts its tool results;
+     * this closes the same gap for the detector-supplied context.)
+     */
+    return ToolResultSerializer.redact(lines.join("\n")).text;
   }
 
   /*

package/Server/Utils/AI/SRE/SubjectCodeFixRun.ts

@@ -116,6 +116,45 @@ export default class SubjectCodeFixRun {
     );
   }
 
+  /*
+   * Per-(service, recipe) dedupe for the service-scoped instrumentation
+   * recipes (ImproveLogging / ImproveTracing): at most one non-terminal
+   * run of a recipe per (project, telemetryServiceId). Same in-memory
+   * taskContext matching as the per-trace guard above — the id lives in
+   * JSON the Query layer cannot filter on, and the candidate set is
+   * bounded and rare.
+   */
+  @CaptureSpan()
+  public static async findNonTerminalRunForTelemetryService(data: {
+    projectId: ObjectID;
+    taskType: CodeFixTaskType;
+    telemetryServiceId: string;
+  }): Promise<AIRun | null> {
+    const activeRuns: Array<AIRun> = await AIRunService.findBy({
+      query: {
+        projectId: data.projectId,
+        runType: AIRunType.CodeFix,
+        codeFixTaskType: data.taskType,
+        status: QueryHelper.notIn([
+          AIRunStatus.Completed,
+          AIRunStatus.Error,
+          AIRunStatus.Cancelled,
+          AIRunStatus.Stale,
+        ]),
+      },
+      select: { _id: true, taskContext: true },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: { isRoot: true },
+    });
+
+    return (
+      activeRuns.find((run: AIRun): boolean => {
+        return run.taskContext?.telemetryServiceId === data.telemetryServiceId;
+      }) || null
+    );
+  }
+
   /*
    * Record the durable intent as a Queued CodeFix AIRun that the external
    * agent worker claims via /ai-agent-task/get-pending-task. `userId` is