@oneuptime/common 11.5.4 → 11.5.5

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

@@ -0,0 +1,293 @@
+import ObjectID from "../../../../Types/ObjectID";
+import { AIChatCitation } from "../../../../Types/AI/AIChatTypes";
+import AIService, {
+  AILogResponse,
+  AI_CONFIDENCE_CLASSIFICATION_FEATURE,
+} from "../../../Services/AIService";
+import logger from "../../Logger";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+
+/*
+ * AI SRE — the structured, server-verified confidence signal (G6).
+ *
+ * The vision's §6 threat model forbids deriving control flow from free-form
+ * model prose: adversarial telemetry can steer what the model writes, so a
+ * regex over the analysis (the old INCONCLUSIVE_RE) was forgeable by prompt
+ * injection. This module replaces it with a two-part signal:
+ *
+ *   1. Deterministic evidence floor (pure, no LLM): computed from the run's
+ *      OWN recorded tool activity. Citations are minted server-side from
+ *      validated tool arguments — never by the model — so prose cannot fake
+ *      evidence that was never minted. Zero citations AND zero data-bearing
+ *      tool calls → INCONCLUSIVE, regardless of anything the analysis says.
+ *
+ *   2. Constrained classification (only when the floor passes): ONE metered
+ *      LLM call (temperature 0, tiny token cap, word-bounded single-token
+ *      parse — the InvestigationGrader idiom) asking whether the analysis
+ *      asserts a specific, evidenced root cause or is inconclusive. The
+ *      classifier sees the analysis as DATA and can only emit one of two
+ *      tokens — it cannot be steered into an arbitrary control decision.
+ *
+ * FAIL DIRECTIONS ARE PER-CONSUMER, and that is the point of the structured
+ * result: `{confident, source}` lets each consumer choose its own safe
+ * degradation when the classification itself failed (unparseable response or
+ * the call errored). As implemented:
+ *
+ *   | source                | confident | workspace ping | instrumentation PR |
+ *   |-----------------------|-----------|----------------|--------------------|
+ *   | deterministic-floor   | false     | no (quiet)     | yes (enqueue)      |
+ *   | classification        | true      | yes            | no                 |
+ *   | classification        | false     | no (quiet)     | yes (enqueue)      |
+ *   | classification-failed | false (*) | YES — louder   | NO — no PR         |
+ *
+ *   - The workspace ping treats classification-failed as CONFIDENT: quiet
+ *     mode's fail direction is "louder, not silent" (vision §6) — a broken
+ *     classifier must never suppress the on-call ping.
+ *   - The instrumentation trigger treats classification-failed as
+ *     NOT-inconclusive: autonomous PR creation (G11 posture) requires a
+ *     POSITIVE, verified inconclusive verdict — "we don't know" must fail
+ *     toward doing nothing.
+ *   - (*) When source is "classification-failed" the `confident` boolean is
+ *     a placeholder, NOT a verdict — consumers must route decisions through
+ *     the helpers below, never through the raw boolean.
+ *
+ * Budget accounting: the classification call runs AFTER the investigation's
+ * agent loop has finished, so it is deliberately OUTSIDE the engine's per-run
+ * caps (MAX_LLM_CALLS / MAX_OUTPUT_TOKENS govern the loop, whose counts are
+ * persisted at the Completed transition before this call fires). It is still
+ * metered per-call in LlmLog and its feature is in AUTONOMOUS_AI_FEATURES, so
+ * the G4 daily autonomous token budget covers it — and a budget rejection
+ * degrades the signal to "classification-failed", never a run failure.
+ */
+
+/*
+ * Persisted LlmLog label, and a member of AUTONOMOUS_AI_FEATURES (G4 budget).
+ * Owned by AIService so this writer and the budget match-list cannot drift —
+ * a drift would silently drop classification out of the budget forever.
+ */
+export const CONFIDENCE_CLASSIFICATION_FEATURE: string =
+  AI_CONFIDENCE_CLASSIFICATION_FEATURE;
+
+// Truncation cap keeps the classification call cheap and inside context limits.
+const MAX_ANALYSIS_CHARS: number = 8000;
+
+/*
+ * Word-bounded token matchers (hoisted: wrap-regex and prettier disagree
+ * inline). Word boundaries mean CONFIDENTLY / INCONCLUSIVELY do not parse.
+ */
+const CONFIDENT_RE: RegExp = /\bCONFIDENT\b/;
+const INCONCLUSIVE_RE: RegExp = /\bINCONCLUSIVE\b/;
+
+export type ConfidenceSource =
+  // The evidence floor failed: zero server-minted evidence exists.
+  | "deterministic-floor"
+  // The constrained classification call returned exactly one valid token.
+  | "classification"
+  // The classification call errored or its response was unparseable.
+  | "classification-failed";
+
+export interface ConfidenceSignal {
+  /*
+   * Whether the investigation asserted an evidenced root cause. NOT a verdict
+   * when source is "classification-failed" — use the decision helpers.
+   */
+  confident: boolean;
+  source: ConfidenceSource;
+}
+
+/*
+ * The deterministic inputs, derived from the run's own recorded tool activity
+ * (server-side state — the model never writes any of these numbers).
+ */
+export interface EvidenceInput {
+  // Citations minted by the engine (one per successful tool call).
+  citationCount: number;
+  // Successful tool calls whose result carried at least one row of data.
+  dataBearingToolCallCount: number;
+  // Whether ANY tool returned non-empty data.
+  anyToolReturnedData: boolean;
+}
+
+export default class AIConfidenceSignal {
+  /*
+   * THE single definition of "data-bearing" (shared with the eval harness in
+   * Utils/AI/Eval): a tool result that carried at least one row of data.
+   * rowCount 0 is still server-verified evidence — proof of absence ("checked,
+   * found nothing") — but it is not data-BEARING. Both the live confidence
+   * floor (over minted citations) and the offline corpus derivation (over
+   * recorded AIRunEvent resultSummary.rowCount) route through this helper so
+   * the two can never drift apart.
+   */
+  public static isDataBearingRowCount(
+    rowCount: number | null | undefined,
+  ): boolean {
+    return (rowCount || 0) > 0;
+  }
+
+  // Derive the deterministic evidence inputs from the run's minted citations.
+  public static evidenceFromCitations(
+    citations: Array<AIChatCitation>,
+  ): EvidenceInput {
+    const dataBearingToolCallCount: number = citations.filter(
+      (citation: AIChatCitation) => {
+        return this.isDataBearingRowCount(citation.rowCount);
+      },
+    ).length;
+
+    return {
+      citationCount: citations.length,
+      dataBearingToolCallCount,
+      anyToolReturnedData: dataBearingToolCallCount > 0,
+    };
+  }
+
+  /*
+   * The deterministic floor (pure, exported for tests): zero citations AND
+   * zero successful data-bearing tool calls → no server-verified evidence
+   * exists, so the run is INCONCLUSIVE no matter what the prose claims.
+   * Prose cannot fake evidence that was never minted server-side.
+   */
+  public static hasVerifiableEvidence(evidence: EvidenceInput): boolean {
+    return (
+      evidence.citationCount > 0 ||
+      evidence.dataBearingToolCallCount > 0 ||
+      evidence.anyToolReturnedData
+    );
+  }
+
+  /*
+   * Defensive one-token parse (pure, exported for tests). The prompt demands
+   * exactly one token, but models editorialize — accept the verdict when
+   * exactly ONE of the two tokens appears, word-bounded. Both found, neither
+   * found, or empty → null (classification failed; per-consumer fail
+   * directions apply).
+   */
+  public static parseClassificationToken(
+    response: string | null | undefined,
+  ): boolean | null {
+    if (!response) {
+      return null;
+    }
+
+    const text: string = response.toUpperCase();
+
+    const isConfident: boolean = CONFIDENT_RE.test(text);
+    const isInconclusive: boolean = INCONCLUSIVE_RE.test(text);
+
+    if (isConfident === isInconclusive) {
+      // Both or neither → unparseable.
+      return null;
+    }
+
+    return isConfident;
+  }
+
+  /*
+   * Consumer decision: should the analysis post ping the workspace/on-call?
+   * Fail direction: classification-failed → TRUE. Quiet mode fails LOUDER,
+   * not silent — a broken classifier must never suppress the ping (the old
+   * regex's fail direction, kept deliberately).
+   */
+  public static shouldSendWorkspaceNotification(
+    signal: ConfidenceSignal,
+  ): boolean {
+    if (signal.source === "classification-failed") {
+      return true;
+    }
+
+    return signal.confident;
+  }
+
+  /*
+   * Consumer decision: should an ImproveInstrumentation fix task be enqueued
+   * (opted-in projects only — the trigger has its own gates)? Requires a
+   * POSITIVE inconclusive verdict: either the deterministic floor proved no
+   * evidence exists, or the classification said INCONCLUSIVE. Fail direction:
+   * classification-failed → FALSE — autonomous PR creation fails toward
+   * doing nothing (G11 posture).
+   */
+  public static shouldEnqueueInstrumentationTask(
+    signal: ConfidenceSignal,
+  ): boolean {
+    if (signal.source === "classification-failed") {
+      return false;
+    }
+
+    return !signal.confident;
+  }
+
+  /*
+   * Compute the full signal: deterministic floor first (no LLM call when it
+   * fails), then one constrained classification call. NEVER throws — an
+   * errored or unparseable classification returns "classification-failed"
+   * and each consumer applies its own fail direction.
+   */
+  @CaptureSpan()
+  public static async computeConfidenceSignal(data: {
+    projectId: ObjectID;
+    aiRunId: ObjectID;
+    analysisMarkdown: string;
+    evidence: EvidenceInput;
+  }): Promise<ConfidenceSignal> {
+    if (!this.hasVerifiableEvidence(data.evidence)) {
+      /*
+       * No server-minted evidence exists — inconclusive by construction,
+       * regardless of the prose. No classification call is spent.
+       */
+      return { confident: false, source: "deterministic-floor" };
+    }
+
+    try {
+      const response: AILogResponse = await AIService.executeWithLogging({
+        projectId: data.projectId,
+        feature: CONFIDENCE_CLASSIFICATION_FEATURE,
+        aiRunId: data.aiRunId,
+        // The verdict drives control flow; no prompt previews in LlmLog.
+        storeContentPreviews: false,
+        temperature: 0,
+        maxTokens: 20,
+        messages: [
+          {
+            role: "system",
+            content: [
+              "You judge an AI incident investigation's own analysis.",
+              "Does this analysis assert a specific root cause with supporting evidence, or is it inconclusive?",
+              "Reply with exactly one token and nothing else:",
+              "CONFIDENT — the analysis asserts a specific root cause with supporting evidence.",
+              "INCONCLUSIVE — the analysis could not determine a cause, or asserts one without supporting evidence.",
+            ].join("\n"),
+          },
+          {
+            role: "user",
+            content: [
+              "AI investigation analysis:",
+              '"""',
+              data.analysisMarkdown.substring(0, MAX_ANALYSIS_CHARS),
+              '"""',
+              "",
+              "One token only: CONFIDENT or INCONCLUSIVE.",
+            ].join("\n"),
+          },
+        ],
+      });
+
+      const verdict: boolean | null = this.parseClassificationToken(
+        response.content,
+      );
+
+      if (verdict === null) {
+        logger.warn(
+          `AI confidence: unparseable classification response for run ${data.aiRunId.toString()} — per-consumer fail directions apply.`,
+        );
+        return { confident: false, source: "classification-failed" };
+      }
+
+      return { confident: verdict, source: "classification" };
+    } catch (error) {
+      logger.error(
+        `AI confidence: classification call failed for run ${data.aiRunId.toString()} — per-consumer fail directions apply: ${error}`,
+      );
+      return { confident: false, source: "classification-failed" };
+    }
+  }
+}

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

@@ -0,0 +1,115 @@
+import ObjectID from "../../../../Types/ObjectID";
+import AIRunType from "../../../../Types/AI/AIRunType";
+import AIRunStatus from "../../../../Types/AI/AIRunStatus";
+import CodeFixTaskType from "../../../../Types/AI/CodeFixTaskType";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import AIRun from "../../../../Models/DatabaseModels/AIRun";
+import AIRunService from "../../../Services/AIRunService";
+import SubjectCodeFixRun from "./SubjectCodeFixRun";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+
+/*
+ * AI SRE — the FixFromIncident trigger (the roadmap's headline `code_fix`
+ * capability, vision §4.8, in human-triggered form).
+ *
+ * After a AI investigation posts a root-cause analysis on an incident
+ * or alert, the user can click "Open Fix PR from this analysis" on the
+ * investigation panel: the agent takes the posted analysis (the RootCause
+ * feed item) as its entire context and opens a fix pull request. Unlike the
+ * ImproveInstrumentation sibling this is NOT automatic — a human reads the
+ * analysis and decides a fix PR is worth opening, so no project opt-in flag
+ * is needed: the human in the loop IS the gate (G11 posture preserved).
+ *
+ * And unlike InstrumentationTaskTrigger (fire-and-forget inside the
+ * investigation's postAnalysis, never throws), this runs inside a
+ * user-facing endpoint (POST /ai-investigation/create-fix-task) and FAILS
+ * EARLY with a clear message when a gate is not met.
+ */
+export default class FixFromIncidentTaskTrigger {
+  /*
+   * Gate and enqueue a FixFromIncident CodeFix run for the subject. The
+   * caller must already have access-checked the subject under the USER's
+   * permissions — this method reads and writes as root. Exactly one of
+   * incidentId/alertId is expected; userId is the clicking user
+   * (attribution on the run).
+   *
+   * Throws BadDataException naming the failed gate: no completed
+   * investigation, no GitHub-App repository, or a duplicate active run.
+   */
+  @CaptureSpan()
+  public static async createFixTaskFromInvestigation(data: {
+    projectId: ObjectID;
+    incidentId?: ObjectID | undefined;
+    alertId?: ObjectID | undefined;
+    userId: ObjectID;
+  }): Promise<AIRun> {
+    if (!data.incidentId && !data.alertId) {
+      throw new BadDataException(
+        "An incident or alert subject is required to create a fix task.",
+      );
+    }
+
+    const subjectLabel: "incident" | "alert" = data.incidentId
+      ? "incident"
+      : "alert";
+
+    /*
+     * Gate 1: a COMPLETED investigation must exist for the subject — its
+     * posted analysis (the RootCause feed item) is the fix task's entire
+     * context. Without one the worker would have nothing to work from.
+     */
+    const completedInvestigation: AIRun | null = await AIRunService.findOneBy({
+      query: {
+        runType: AIRunType.Investigation,
+        status: AIRunStatus.Completed,
+        ...(data.incidentId
+          ? { triggeredByIncidentId: data.incidentId }
+          : { triggeredByAlertId: data.alertId! }),
+      },
+      select: { _id: true },
+      props: { isRoot: true },
+    });
+
+    if (!completedInvestigation) {
+      throw new BadDataException(
+        `No completed AI investigation exists for this ${subjectLabel} — the fix task uses the investigation's posted analysis as its context. Wait for the investigation to complete, or enable AI investigations in the AI settings.`,
+      );
+    }
+
+    // Gate 2: a repository the agent can actually open a PR against.
+    const hasConnectedRepository: boolean =
+      await SubjectCodeFixRun.hasGitHubAppConnectedRepository(data.projectId);
+
+    if (!hasConnectedRepository) {
+      throw new BadDataException(
+        "No GitHub-App-connected repository exists for this project, so the agent has nowhere to open the fix pull request. Connect one under AI > Code Repositories.",
+      );
+    }
+
+    /*
+     * Gate 3: per-subject dedupe — at most one non-terminal FixFromIncident
+     * run per incident/alert (repeated clicks must not fan out into
+     * duplicate PRs).
+     */
+    const existingRun: AIRun | null =
+      await SubjectCodeFixRun.findNonTerminalRunForSubject({
+        taskType: CodeFixTaskType.FixFromIncident,
+        incidentId: data.incidentId,
+        alertId: data.alertId,
+      });
+
+    if (existingRun) {
+      throw new BadDataException(
+        `A fix pull request task is already queued or running for this ${subjectLabel}. Track its progress on the AI > Tasks page.`,
+      );
+    }
+
+    return SubjectCodeFixRun.enqueueSubjectCodeFixRun({
+      projectId: data.projectId,
+      taskType: CodeFixTaskType.FixFromIncident,
+      incidentId: data.incidentId,
+      alertId: data.alertId,
+      userId: data.userId,
+    });
+  }
+}

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

@@ -0,0 +1,223 @@
+import ObjectID from "../../../../Types/ObjectID";
+import CodeFixTaskType from "../../../../Types/AI/CodeFixTaskType";
+import CodeFixTaskContext, {
+  PerformanceCodeLocation,
+  PerformanceFinding,
+} from "../../../../Types/AI/CodeFixTaskContext";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import AIRun from "../../../../Models/DatabaseModels/AIRun";
+import SpanTreeAnalyzer, {
+  AnalyzableSpan,
+} from "../PerfEvidence/SpanTreeAnalyzer";
+import SubjectCodeFixRun from "./SubjectCodeFixRun";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+
+/*
+ * AI SRE — the FixPerformance trigger: from a slow trace, one click opens
+ * a performance-fix pull request grounded in the actual span-tree evidence.
+ *
+ * The gate that makes this recipe honest is DETERMINISTIC: the
+ * SpanTreeAnalyzer must find a mechanical performance pattern (N+1,
+ * dominant span, sequential-that-could-be-parallel) in the trace's spans,
+ * or the task is refused — the agent never goes hunting for "something
+ * slow" on vibes. Like FixFromIncident (b4) this is human-triggered from a
+ * user-facing endpoint (POST /ai-investigation/create-performance-fix-task),
+ * so there is no project opt-in flag — the human in the loop IS the gate —
+ * and every unmet gate FAILS EARLY with a clear message.
+ *
+ * The findings (plus best-effort service attribution and code.* locations
+ * for repository resolution) are serialized into AIRun.taskContext at
+ * enqueue time: ClickHouse span retention is short, so by the time the
+ * worker claims the run the spans may be gone. The stored evidence IS the
+ * task's context.
+ */
+
+// Max code.* locations stored — mirrors the resolver's own candidate cap.
+const MAX_CODE_LOCATIONS: number = 10;
+
+export default class FixPerformanceTaskTrigger {
+  /*
+   * Collect code.filepath/code.function/code.lineno (and their newer
+   * semconv spellings) from the spans a finding implicates, so the
+   * task-details endpoint can attempt stack-trace-style repository
+   * resolution. Best-effort: most instrumentations do not stamp code
+   * attributes on client spans, and an empty result just means the
+   * resolver falls back to name-match / only-repository.
+   */
+  public static collectCodeLocations(
+    spans: Array<AnalyzableSpan>,
+    findings: Array<PerformanceFinding>,
+  ): Array<PerformanceCodeLocation> {
+    const implicatedSpanIds: Set<string> = new Set();
+
+    for (const finding of findings) {
+      for (const implicated of finding.implicatedSpans) {
+        implicatedSpanIds.add(implicated.spanId);
+      }
+    }
+
+    const locations: Array<PerformanceCodeLocation> = [];
+    const seenFilePaths: Set<string> = new Set();
+
+    for (const span of spans) {
+      if (!implicatedSpanIds.has(span.spanId) || !span.attributes) {
+        continue;
+      }
+
+      const filePath: string | undefined =
+        span.attributes["code.filepath"] || span.attributes["code.file.path"];
+
+      if (!filePath || seenFilePaths.has(filePath)) {
+        continue;
+      }
+
+      seenFilePaths.add(filePath);
+
+      const functionName: string | undefined =
+        span.attributes["code.function"] ||
+        span.attributes["code.function.name"];
+
+      const rawLineNumber: string | undefined =
+        span.attributes["code.lineno"] || span.attributes["code.line.number"];
+      const lineNumber: number = rawLineNumber
+        ? parseInt(rawLineNumber, 10)
+        : NaN;
+
+      locations.push({
+        filePath,
+        functionName,
+        lineNumber: Number.isFinite(lineNumber) ? lineNumber : undefined,
+      });
+
+      if (locations.length >= MAX_CODE_LOCATIONS) {
+        break;
+      }
+    }
+
+    return locations;
+  }
+
+  /*
+   * Gate and enqueue a FixPerformance CodeFix run for a trace. The caller
+   * must already have loaded the spans under the USER's telemetry-read
+   * permissions (the access check) — this method reads and writes as root.
+   *
+   * Throws BadDataException naming the failed gate: no deterministic
+   * finding, no GitHub-App repository, or a duplicate active run for the
+   * same trace.
+   */
+  @CaptureSpan()
+  public static async createPerformanceFixTaskFromTrace(data: {
+    projectId: ObjectID;
+    traceId: string;
+    spans: Array<AnalyzableSpan>;
+    serviceName?: string | undefined;
+    userId: ObjectID;
+  }): Promise<AIRun> {
+    if (!data.traceId) {
+      throw new BadDataException(
+        "A traceId is required to create a performance fix task.",
+      );
+    }
+
+    if (data.spans.length === 0) {
+      throw new BadDataException(
+        "This trace has no spans to analyze (or you do not have access to them).",
+      );
+    }
+
+    /*
+     * Gate 1 — the deterministic evidence gate, and the recipe's whole
+     * point: no mechanical pattern in the span tree means no fix task.
+     * This gate lives HERE, not in the findings entry point below: callers
+     * of that entry point (insight fix routing) hand over findings that
+     * were already computed — and gated on — at detect time.
+     */
+    const findings: Array<PerformanceFinding> = SpanTreeAnalyzer.analyzeTrace(
+      data.spans,
+    );
+
+    if (findings.length === 0) {
+      throw new BadDataException(
+        "No deterministic performance pattern was found in this trace. The analyzer looks for N+1 patterns (5+ near-identical sibling spans), a dominant slow span (60%+ of the trace), and sequential same-operation siblings that could run in parallel (3+, 50%+ of their parent) — none matched, so the AI agent has no grounded evidence to fix.",
+      );
+    }
+
+    return this.createPerformanceFixTaskFromFindings({
+      projectId: data.projectId,
+      traceId: data.traceId,
+      serviceName: data.serviceName,
+      findings,
+      codeLocations: this.collectCodeLocations(data.spans, findings),
+      userId: data.userId,
+    });
+  }
+
+  /*
+   * The findings-based entry point: gate and enqueue a FixPerformance run
+   * for ALREADY-COMPUTED deterministic findings (the spans path above after
+   * its analyzer gate, and AI insight fix routing whose findings were
+   * drilled — and stored as evidence — at detect time, because the spans
+   * are likely gone by now). `userId` is attribution for human-triggered
+   * callers; automatic triggers pass none and the run stays system-authored.
+   *
+   * Throws BadDataException naming the failed gate: no GitHub-App
+   * repository, a duplicate active run for the same trace, or (via
+   * enqueueSubjectCodeFixRun) the daily fix-run budget.
+   */
+  @CaptureSpan()
+  public static async createPerformanceFixTaskFromFindings(data: {
+    projectId: ObjectID;
+    traceId: string;
+    serviceName?: string | undefined;
+    findings: Array<PerformanceFinding>;
+    codeLocations: Array<PerformanceCodeLocation>;
+    userId?: ObjectID | undefined;
+  }): Promise<AIRun> {
+    if (!data.traceId) {
+      throw new BadDataException(
+        "A traceId is required to create a performance fix task.",
+      );
+    }
+
+    // Gate — a repository the agent can actually open a PR against.
+    const hasConnectedRepository: boolean =
+      await SubjectCodeFixRun.hasGitHubAppConnectedRepository(data.projectId);
+
+    if (!hasConnectedRepository) {
+      throw new BadDataException(
+        "No GitHub-App-connected repository exists for this project, so the agent has nowhere to open the performance-fix pull request. Connect one under AI > Code Repositories.",
+      );
+    }
+
+    /*
+     * Gate — per-trace dedupe: at most one non-terminal FixPerformance
+     * run per trace (repeated clicks must not fan out into duplicate PRs).
+     */
+    const existingRun: AIRun | null =
+      await SubjectCodeFixRun.findNonTerminalPerformanceFixRunForTrace({
+        projectId: data.projectId,
+        traceId: data.traceId,
+      });
+
+    if (existingRun) {
+      throw new BadDataException(
+        "A performance fix task is already queued or running for this trace. Track its progress on the AI > Tasks page.",
+      );
+    }
+
+    const taskContext: CodeFixTaskContext = {
+      traceId: data.traceId,
+      serviceName: data.serviceName,
+      performanceFindings: data.findings,
+      codeLocations: data.codeLocations,
+    };
+
+    return SubjectCodeFixRun.enqueueSubjectCodeFixRun({
+      projectId: data.projectId,
+      taskType: CodeFixTaskType.FixPerformance,
+      userId: data.userId,
+      taskContext,
+    });
+  }
+}