@oneuptime/common 11.5.11 → 11.5.13

package/Models/AnalyticsModels/NetworkFlow.ts

@@ -285,8 +285,19 @@ export default class NetworkFlow extends AnalyticsBaseModel {
        * (a retentionDate column computed at ingest, like Log/Metric) is
        * the phase-2 follow-up. Keyed on server-assigned ingestedAt so a
        * device with a wrong clock cannot make rows expire early.
+       *
+       * toDateTime() is NOT redundant: ingestedAt is DateTime64(9), so
+       * `ingestedAt + INTERVAL 30 DAY` stays DateTime64(9), and a TTL
+       * expression must evaluate to Date or DateTime. ClickHouse only began
+       * accepting DateTime64 there in 25.x; on 24.x it fails the CREATE with
+       * BAD_TTL_EXPRESSION, which aborts the whole boot schema-sync (it has
+       * no per-table error handling) and takes every table registered after
+       * this one down with it. The Helm chart ships `tag: latest` but tells
+       * operators to pin for production, so older servers are supported and
+       * this must stay version-portable. Narrowing to second precision is
+       * lossless for a 30-day retention window.
        */
-      ttlExpression: "ingestedAt + INTERVAL 30 DAY DELETE",
+      ttlExpression: "toDateTime(ingestedAt) + INTERVAL 30 DAY DELETE",
       defaultSortColumn: "flowStartAt",
     });
   }

package/Models/DatabaseModels/AIInsight.ts

@@ -205,6 +205,36 @@ export default class AIInsight extends BaseModel {
   })
   public severity?: AIInsightSeverity = undefined;
 
+  /*
+   * Triage verdict (ExceptionAIClassification values) written by the
+   * insight triage runner. Null until triage completes. The automatic
+   * fix lane only opens pull requests for insights triaged as
+   * code-fault — see InsightScanner / InsightFixRouting.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "Classification",
+    description:
+      "AI triage verdict: code-fault, user-error, expected-denial, infrastructure or unknown. Automatic fix pull requests are only opened for code-fault.",
+    canReadOnRelationQuery: true,
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public classification?: string = undefined;
+
   /*
    * The detector's stable dedupe key for this finding (e.g.
    * "new-exception:<telemetryExceptionId>"). The scanner refreshes the

package/Models/DatabaseModels/Project.ts

@@ -1599,6 +1599,36 @@ export default class Project extends TenantModel {
   })
   public enableInsightFixTasks?: boolean = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.ReadProject,
+      Permission.UnAuthorizedSsoUser,
+      Permission.ProjectUser,
+    ],
+    update: [Permission.ProjectOwner, Permission.ProjectAdmin],
+  })
+  @TableColumn({
+    required: true,
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    title: "Auto Archive Non-Actionable Exceptions",
+    description:
+      "When enabled, exception groups the AI triage classifies as expected denials (auth failures, plan/paywall rejections, scanner probes tripping intentional validation) are automatically archived so they stop surfacing in the unresolved list and never queue AI fix tasks. Groups classified as user errors or infrastructure conditions are NOT auto-archived — only clear expected denials are. Archiving is reversible from the Archived tab.",
+    defaultValue: false,
+    example: true,
+  })
+  @Column({
+    nullable: false,
+    default: false,
+    type: ColumnType.Boolean,
+  })
+  public autoArchiveNonActionableExceptions?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [

package/Models/DatabaseModels/TelemetryException.ts

@@ -1281,4 +1281,132 @@ export default class TelemetryException extends DatabaseBaseModel {
     length: ColumnLength.LongText,
   })
   public environment?: string = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * Server-written only (isRoot bypasses column ACL): this is derived
+     * state maintained by ingest / triage / the PR-state sync — a client
+     * PATCH must not be able to set it (the value flows into LLM prompts
+     * and public PR text, and it gates the automatic fix lane).
+     */
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.TelemetryAdmin,
+      Permission.TelemetryMember,
+      Permission.TelemetryViewer,
+      Permission.ReadTelemetryException,
+    ],
+    update: [],
+  })
+  /*
+   * Sticky rollup of the OTel exception.escaped flag: true once ANY
+   * occurrence of this group escaped its span scope (was unhandled).
+   * Maintained by the ingest upsert with `unhandled OR EXCLUDED.unhandled`
+   * — a group never flips back to handled. Handled exceptions are usually
+   * expected/operational errors, which is a key signal for deciding
+   * whether an AI fix PR is warranted.
+   */
+  @TableColumn({
+    title: "Unhandled",
+    description:
+      "True when at least one occurrence of this exception escaped its span scope (was unhandled, per OTel exception.escaped)",
+    isDefaultValueColumn: true,
+    required: true,
+    type: TableColumnType.Boolean,
+    defaultValue: false,
+    example: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    unique: false,
+    default: false,
+  })
+  public unhandled?: boolean = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * Server-written only (isRoot bypasses column ACL): this is derived
+     * state maintained by ingest / triage / the PR-state sync — a client
+     * PATCH must not be able to set it (the value flows into LLM prompts
+     * and public PR text, and it gates the automatic fix lane).
+     */
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.TelemetryAdmin,
+      Permission.TelemetryMember,
+      Permission.TelemetryViewer,
+      Permission.ReadTelemetryException,
+    ],
+    update: [],
+  })
+  /*
+   * Verdict of the AI insight triage for this exception group: is this a
+   * code defect the AI should try to fix, an expected end-user error, an
+   * expected denial (auth/paywall/probe), or an infrastructure condition?
+   * Values come from ExceptionAIClassification. Written by the triage
+   * runner; the automatic fix lane only opens PRs for CodeFault groups.
+   */
+  @TableColumn({
+    title: "AI Classification",
+    description:
+      "AI triage verdict for this exception group (code-fault, user-error, expected-denial, infrastructure)",
+    required: false,
+    type: TableColumnType.ShortText,
+    example: "code-fault",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public aiClassification?: string = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * Server-written only (isRoot bypasses column ACL): this is derived
+     * state maintained by ingest / triage / the PR-state sync — a client
+     * PATCH must not be able to set it (the value flows into LLM prompts
+     * and public PR text, and it gates the automatic fix lane).
+     */
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.TelemetryAdmin,
+      Permission.TelemetryMember,
+      Permission.TelemetryViewer,
+      Permission.ReadTelemetryException,
+    ],
+    update: [],
+  })
+  /*
+   * Stamped when a human closes an AI-authored fix PR for this exception
+   * without merging it — the strongest "the AI fix was not wanted" signal.
+   * The automatic fix lane skips groups carrying this stamp; a human
+   * clicking "Fix with AI" on the exception page clears it and retries.
+   */
+  @TableColumn({
+    title: "AI Fix Declined At",
+    description:
+      "Set when an AI-authored fix pull request for this exception was closed without merging; suppresses further automatic fix attempts",
+    required: false,
+    type: TableColumnType.Date,
+    example: "2026-01-01T00:00:00.000Z",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.Date,
+  })
+  public aiFixDeclinedAt?: Date = undefined;
 }

package/Server/API/AIAgentDataAPI.ts

@@ -43,6 +43,11 @@ import CodeFixTaskContext, {
   PerformanceFinding,
 } from "../../Types/AI/CodeFixTaskContext";
 import SpanTreeAnalyzer from "../Utils/AI/PerfEvidence/SpanTreeAnalyzer";
+import {
+  sanitizeExceptionMessage,
+  sanitizeStackTrace,
+} from "../Utils/Telemetry/ExceptionSanitizer";
+import ToolResultSerializer from "../Utils/AI/Toolbox/Serializer";
 import OpenPullRequestCap, {
   OpenPullRequestCapDecision,
 } from "../Utils/AI/CodeFix/OpenPullRequestCap";
@@ -204,6 +209,7 @@ export default class AIAgentDataAPI {
                 stackTrace: true,
                 exceptionType: true,
                 fingerprint: true,
+                aiClassification: true,
                 primaryEntityId: true,
                 primaryEntityType: true,
               },
@@ -221,7 +227,7 @@ export default class AIAgentDataAPI {
           }
 
           logger.debug(
-            `Exception details fetched: ${exception._id} - ${exception.message?.substring(0, 100)}`,
+            `Exception details fetched: ${exception._id}`,
             getLogAttributesFromRequest(req as any),
           );
 
@@ -245,13 +251,24 @@ export default class AIAgentDataAPI {
               })
             : null;
 
+          /*
+           * Sanitize at the choke point: everything the AI agent worker
+           * sees — and therefore everything that can end up in an LLM
+           * prompt, a public pull-request title/body, or a commit
+           * message — flows through this response. The message gets
+           * dynamic-token normalization + secret redaction; the stack
+           * trace gets redaction only, so file:line frames stay intact
+           * for the code agent.
+           */
           return Response.sendJsonObjectResponse(req, res, {
             exception: {
               id: exception._id?.toString(),
-              message: exception.message,
-              stackTrace: exception.stackTrace,
-              exceptionType: exception.exceptionType,
+              message: sanitizeExceptionMessage(exception.message || ""),
+              stackTrace: sanitizeStackTrace(exception.stackTrace || ""),
+              // Legacy pre-batch-upsert rows can carry NULL here.
+              exceptionType: exception.exceptionType || "",
               fingerprint: exception.fingerprint,
+              aiClassification: exception.aiClassification || null,
             },
             service: exception.primaryEntityId
               ? {
@@ -518,6 +535,103 @@ export default class AIAgentDataAPI {
             );
           }
 
+          /*
+           * Service-scoped instrumentation recipes (ImproveLogging /
+           * ImproveTracing): the context is just the service — resolve the
+           * repository by service name (no stack trace) and hand the
+           * worker a short brief; the recipe's checklist lives in the
+           * worker's prompt.
+           */
+          if (
+            taskType === CodeFixTaskType.ImproveLogging ||
+            taskType === CodeFixTaskType.ImproveTracing
+          ) {
+            const taskContext: CodeFixTaskContext | undefined = run.taskContext;
+            const improvementServiceName: string =
+              taskContext?.serviceName || "";
+
+            if (!taskContext?.telemetryServiceId) {
+              return Response.sendErrorResponse(
+                req,
+                res,
+                new BadDataException(
+                  "This telemetry-improvement task has no stored service context — the task has nothing to work from.",
+                ),
+              );
+            }
+
+            const pillar: string =
+              taskType === CodeFixTaskType.ImproveLogging
+                ? "logging"
+                : "tracing";
+            const subjectTitle: string = improvementServiceName
+              ? `Improve ${pillar} for ${improvementServiceName}`
+              : `Improve ${pillar}`;
+
+            const resolution: RepoResolution | null =
+              await CodeRepositoryService.resolveRepositoryForException({
+                projectId: run.projectId,
+                stackTrace: null,
+                serviceName: improvementServiceName || null,
+              });
+
+            const repository: CodeRepository | null = resolution
+              ? await CodeRepositoryService.findOneById({
+                  id: new ObjectID(resolution.codeRepositoryId),
+                  select: {
+                    _id: true,
+                    name: true,
+                    repositoryHostedAt: true,
+                    organizationName: true,
+                    repositoryName: true,
+                    mainBranchName: true,
+                    gitHubAppInstallationId: true,
+                  },
+                  props: { isRoot: true },
+                })
+              : null;
+
+            const basePayload: JSONObject = {
+              subjectType: "service",
+              subjectTitle,
+              analysisMarkdown: `OneUptime observes the telemetry of the service ${
+                improvementServiceName
+                  ? `"${improvementServiceName}"`
+                  : "in this repository"
+              }. A user asked for its ${pillar} instrumentation to be improved — follow the task checklist in your instructions.`,
+              serviceName: improvementServiceName,
+              projectId: run.projectId.toString(),
+            };
+
+            if (!resolution || !repository) {
+              return Response.sendJsonObjectResponse(req, res, {
+                ...basePayload,
+                repositories: [],
+                resolutionError:
+                  "Could not resolve a repository for this task: no connected repository name matches the service and the project has more than one repository. Connect the right repository via the GitHub App, or rename one to match the service.",
+              });
+            }
+
+            return Response.sendJsonObjectResponse(req, res, {
+              ...basePayload,
+              repositories: [
+                {
+                  id: repository.id!.toString(),
+                  name: repository.name || "",
+                  repositoryHostedAt: repository.repositoryHostedAt || "",
+                  organizationName: repository.organizationName || "",
+                  repositoryName: repository.repositoryName || "",
+                  mainBranchName: repository.mainBranchName || "main",
+                  servicePathInRepository: resolution.servicePathInRepository,
+                  gitHubAppInstallationId:
+                    repository.gitHubAppInstallationId || null,
+                  resolutionMethod: resolution.method,
+                  resolutionEvidence: resolution.evidence,
+                },
+              ],
+            });
+          }
+
           /*
            * Trace-evidence recipes (FixPerformance): everything the worker
            * needs was captured into taskContext at trigger time — the spans
@@ -607,8 +721,10 @@ export default class AIAgentDataAPI {
             const basePayload: JSONObject = {
               subjectType: "trace",
               subjectTitle: findings[0]!.headline,
-              analysisMarkdown:
+              // Redact before it can reach a prompt or PR body.
+              analysisMarkdown: ToolResultSerializer.redact(
                 SpanTreeAnalyzer.renderFindingsMarkdown(findings),
+              ).text,
               serviceName,
               projectId: run.projectId.toString(),
               traceId: taskContext.traceId,
@@ -788,6 +904,14 @@ export default class AIAgentDataAPI {
             );
           }
 
+          /*
+           * The analysis was written by the investigation LLM over
+           * redacted tool results, but quoted exception text can still
+           * carry secrets — sweep it again before it reaches the worker's
+           * prompt and the pull-request body.
+           */
+          analysisMarkdown = ToolResultSerializer.redact(analysisMarkdown).text;
+
           /*
            * Resolve the repository WITHOUT a stack trace — these tasks have
            * no exception, so only the name-match (against the subject's

package/Server/API/AIInvestigationAPI.ts

@@ -31,6 +31,8 @@ import ServiceService from "../Services/ServiceService";
 import SpanService from "../Services/SpanService";
 import FixFromIncidentTaskTrigger from "../Utils/AI/SRE/FixFromIncidentTaskTrigger";
 import FixPerformanceTaskTrigger from "../Utils/AI/SRE/FixPerformanceTaskTrigger";
+import TelemetryImprovementTaskTrigger from "../Utils/AI/SRE/TelemetryImprovementTaskTrigger";
+import CodeFixTaskType from "../../Types/AI/CodeFixTaskType";
 import { AnalyzableSpan } from "../Utils/AI/PerfEvidence/SpanTreeAnalyzer";
 
 const router: ExpressRouter = Express.getRouter();
@@ -575,4 +577,89 @@ router.post(
   },
 );
 
+/*
+ * "Improve logging / tracing with AI" from a telemetry service's Logs or
+ * Traces page: gate and enqueue a service-scoped instrumentation-
+ * improvement CodeFix run (ImproveLogging / ImproveTracing). Human-
+ * triggered — the click is the gate; budget, repository and per-service
+ * dedupe are enforced in the trigger. Returns { aiRunId }.
+ */
+router.post(
+  "/ai-investigation/create-telemetry-improvement-task",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const props: DatabaseCommonInteractionProps = await getLoggedInProps(req);
+
+      const projectId: ObjectID | undefined = props.tenantId;
+
+      if (!projectId) {
+        throw new BadDataException("A project scope is required.");
+      }
+
+      const telemetryServiceIdParam: string | undefined = req.body[
+        "telemetryServiceId"
+      ] as string | undefined;
+
+      if (!telemetryServiceIdParam) {
+        throw new BadDataException("telemetryServiceId is required.");
+      }
+
+      const rawTaskType: string | undefined = req.body["taskType"] as
+        | string
+        | undefined;
+
+      if (
+        rawTaskType !== CodeFixTaskType.ImproveLogging &&
+        rawTaskType !== CodeFixTaskType.ImproveTracing
+      ) {
+        throw new BadDataException(
+          `taskType must be ${CodeFixTaskType.ImproveLogging} or ${CodeFixTaskType.ImproveTracing}.`,
+        );
+      }
+
+      const telemetryServiceId: ObjectID = new ObjectID(
+        telemetryServiceIdParam,
+      );
+
+      /*
+       * Access check under the USER's permissions: the caller must be able
+       * to read the service they are asking the agent to instrument. The
+       * trigger re-reads as root afterwards.
+       */
+      const service: Service | null = await ServiceService.findOneById({
+        id: telemetryServiceId,
+        select: { _id: true },
+        props: props,
+      });
+
+      if (!service) {
+        throw new BadDataException(
+          "Telemetry service not found (or you do not have access to it).",
+        );
+      }
+
+      const run: AIRun =
+        await TelemetryImprovementTaskTrigger.createTelemetryImprovementTask({
+          projectId,
+          telemetryServiceId,
+          taskType: rawTaskType,
+          userId: props.userId!,
+        });
+
+      Response.sendJsonObjectResponse(req, res, {
+        aiRunId: run.id!.toString(),
+      });
+      return;
+    } catch (err) {
+      next(err);
+      return;
+    }
+  },
+);
+
 export default router;

package/Server/API/StatusPageAPI.ts

@@ -88,7 +88,7 @@ import StatusPageEventType from "../../Types/StatusPage/StatusPageEventType";
 import StatusPageResourceUptimeUtil from "../../Utils/StatusPage/ResourceUptime";
 import UptimePrecision from "../../Types/StatusPage/UptimePrecision";
 import { Green } from "../../Types/BrandColors";
-import UptimeUtil from "../../Utils/Uptime/UptimeUtil";
+import UptimeUtil, { UptimeWindow } from "../../Utils/Uptime/UptimeUtil";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import URL from "../../Types/API/URL";
 import SMS from "../../Types/SMS/SMS";
@@ -1265,6 +1265,17 @@ export default class StatusPageAPI extends BaseAPI<
           const downtimeMonitorStatuses: Array<MonitorStatus> =
             statusPage.downtimeMonitorStatuses || [];
 
+          /*
+           * this endpoint reports uptime over an explicit [startDate, endDate] range, so events
+           * have to be clipped to it and the denominator has to be the range itself. Without
+           * this an open (endsAt = null) row that started before the range contributes its
+           * entire duration to the downtime total.
+           */
+          const uptimeWindow: UptimeWindow = {
+            startDate: startDate,
+            endDate: endDate,
+          };
+
           type ResourceUptime = {
             statusPageResourceId: ObjectID;
             uptimePercent: number | null;
@@ -1369,6 +1380,7 @@ export default class StatusPageAPI extends BaseAPI<
                           resourceStatusTimelines,
                           precision,
                           downtimeMonitorStatuses,
+                          uptimeWindow,
                         );
 
                       resourceUptime.uptimePercent = uptimePercent;
@@ -1419,6 +1431,7 @@ export default class StatusPageAPI extends BaseAPI<
                           resourceStatusTimelines,
                           precision,
                           downtimeMonitorStatuses,
+                          uptimeWindow,
                         );
 
                       resourceUptime.uptimePercent = uptimePercent;

package/Server/Infrastructure/Postgres/SchemaMigrations/1784640000000-AddExceptionTriageAndPrivacyColumns.ts

@@ -0,0 +1,56 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * AI exception triage + privacy columns:
+ *
+ * - TelemetryException.unhandled: sticky rollup of OTel exception.escaped
+ *   (maintained by the ingest upsert with OR semantics).
+ * - TelemetryException.aiClassification: triage verdict (code-fault,
+ *   user-error, expected-denial, infrastructure, unknown).
+ * - TelemetryException.aiFixDeclinedAt: stamped when a human closes an
+ *   AI fix PR without merging; suppresses further automatic fix attempts.
+ * - AIInsight.classification: the same triage verdict on the insight row.
+ * - Project.autoArchiveNonActionableExceptions: opt-in auto-archive of
+ *   expected-denial exception groups.
+ */
+export class AddExceptionTriageAndPrivacyColumns1784640000000
+  implements MigrationInterface
+{
+  public name: string = "AddExceptionTriageAndPrivacyColumns1784640000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" ADD "unhandled" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" ADD "aiClassification" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" ADD "aiFixDeclinedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIInsight" ADD "classification" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Project" ADD "autoArchiveNonActionableExceptions" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Project" DROP COLUMN "autoArchiveNonActionableExceptions"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIInsight" DROP COLUMN "classification"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" DROP COLUMN "aiFixDeclinedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" DROP COLUMN "aiClassification"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "TelemetryException" DROP COLUMN "unhandled"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -461,7 +461,7 @@ import { AddNetworkDeviceInventoryAndDiscoverySchedule1784211212164 } from "./17
 import { AddEnterpriseLicenseNotificationColumns1784218257664 } from "./1784218257664-AddEnterpriseLicenseNotificationColumns";
 import { AddAttributionColumnsToUserAndProject1784293516000 } from "./1784293516000-AddAttributionColumnsToUserAndProject";
 import { AddMarketingConversionTable1784298000000 } from "./1784298000000-AddMarketingConversionTable";
-import { MigrationName1784401962564 } from "./1784401962564-MigrationName";
+import { AddExceptionTriageAndPrivacyColumns1784640000000 } from "./1784640000000-AddExceptionTriageAndPrivacyColumns";
 
 export default [
   InitialMigration,
@@ -927,5 +927,5 @@ export default [
   AddEnterpriseLicenseNotificationColumns1784218257664,
   AddAttributionColumnsToUserAndProject1784293516000,
   AddMarketingConversionTable1784298000000,
-  MigrationName1784401962564,
+  AddExceptionTriageAndPrivacyColumns1784640000000,
 ];

package/Server/Services/AIRunService.ts

@@ -187,6 +187,14 @@ export class Service extends DatabaseService<Model> {
           run.triggeredByIncidentId || run.triggeredByAlertId
             ? null
             : "Queued code-fix run has no incident or alert subject.";
+      } else if (
+        run.codeFixTaskType === CodeFixTaskType.ImproveLogging ||
+        run.codeFixTaskType === CodeFixTaskType.ImproveTracing
+      ) {
+        // Service-scoped instrumentation recipes carry the service instead.
+        missingContextMessage = run.taskContext?.telemetryServiceId
+          ? null
+          : "Queued code-fix run has no telemetry service in its task context.";
       } else {
         missingContextMessage = run.taskContext?.traceId
           ? null