@oneuptime/common 14.0.11 → 14.0.12

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

@@ -6,6 +6,7 @@ import InvestigationEligibility from "./InvestigationEligibility";
 import ObjectID from "../../../../Types/ObjectID";
 import OneUptimeDate from "../../../../Types/Date";
 import AIRunType from "../../../../Types/AI/AIRunType";
+import AIWorkloadLimits from "../../../../Types/AI/AIWorkloadLimits";
 import QueryHelper from "../../../Types/Database/QueryHelper";
 import Incident from "../../../../Models/DatabaseModels/Incident";
 import IncidentSeverity from "../../../../Models/DatabaseModels/IncidentSeverity";
@@ -62,14 +63,11 @@ import CaptureSpan from "../../Telemetry/CaptureSpan";
  * pod restart can no longer orphan an investigation; the heavy lifting (run
  * lifecycle, the agent loop, confidence gating) lives in the shared
  * AIInvestigationEngine.
+ *
+ * A project may narrow which incidents are investigated with a severity floor
+ * and a per-monitor cooldown. Both are off until a project sets them, so by
+ * default every incident is investigated.
  */
-/*
- * The cooldown default. Matches the alert lane: a monitor that was just
- * investigated does not need a second opinion minutes later.
- */
-export const DEFAULT_INCIDENT_DEDUPE_WINDOW_MINUTES: number = 30;
-
-const MAX_INCIDENT_DEDUPE_WINDOW_MINUTES: number = 24 * 60;
 
 export interface IncidentGateDecision {
   investigate: boolean;
@@ -243,17 +241,12 @@ export default class AIIncidentInvestigationRunner {
     }
 
     /*
-     * Per-monitor dedupe window: per-project override, defaulting to 30
-     * minutes, clamped to at most a day; 0 disables the cooldown. An incident
-     * affecting no monitor has no dedupe key.
+     * Per-monitor cooldown: off unless the project sets one, clamped to at
+     * most a day (see AIWorkloadLimits). An incident affecting no monitor has
+     * no dedupe key.
      */
-    const dedupeWindowMinutes: number = Math.min(
-      MAX_INCIDENT_DEDUPE_WINDOW_MINUTES,
-      Math.max(
-        0,
-        project?.incidentInvestigationDedupeWindowMinutes ??
-          DEFAULT_INCIDENT_DEDUPE_WINDOW_MINUTES,
-      ),
+    const dedupeWindowMinutes: number = AIWorkloadLimits.getCooldownInMinutes(
+      project?.incidentInvestigationDedupeWindowMinutes,
     );
 
     if (monitorIds.length > 0 && dedupeWindowMinutes > 0) {
@@ -601,8 +594,8 @@ export default class AIIncidentInvestigationRunner {
 
           /*
            * Inconclusive means the telemetry was insufficient — for
-           * opted-in projects (the incident instrumentation-fix setting,
-           * default false), queue an ImproveInstrumentation fix task that
+           * projects with the incident instrumentation-fix setting on (on
+           * for new projects), queue an ImproveInstrumentation fix task that
            * opens a PR adding the missing observability. Runs strictly
            * AFTER the analysis is posted, and the trigger never throws, so
            * the investigation can neither be blocked nor failed by it.

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

@@ -28,11 +28,12 @@ const MAX_FEED_PREVIEW_CHARS: number = 6000;
 export default class AIIncidentPostmortemRunner {
   /*
    * The draft has its own switch, separate from automatic incident
-   * investigation. Investigations are read-only and on by default for new
-   * projects; a draft writes to the incident and posts to the project's
-   * Slack/Teams channels, so a project turns it on deliberately (opt-in:
-   * === true). The AI kill switch, the LLM provider and the AI balance gate
-   * it exactly as they gate an investigation.
+   * investigation, because a draft writes to the incident and posts to the
+   * project's Slack/Teams channels where an investigation only reads. Both
+   * are on for new projects; a project that existed before keeps its own
+   * value, and unset reads as off (=== true). The AI kill switch, the LLM
+   * provider and the AI balance gate it exactly as they gate an
+   * investigation.
    */
   public static async isEnabledForProject(
     projectId: ObjectID,

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

@@ -19,7 +19,7 @@ import CaptureSpan from "../../../Telemetry/CaptureSpan";
 /*
  * Deterministic fix routing for newly created insights — gated on the
  * Project.enableAi master switch AND on Project.enableInsightFixTasks
- * (default FALSE): insights whose evidence points at code (new/spiking
+ * (on for new projects): insights whose evidence points at code (new/spiking
  * exceptions with a resolvable repository, latency regressions with
  * span-tree findings) queue a CodeFix AIRun that opens a pull request,
  * ready for review. The decision is readiness/evidence-based, never
@@ -74,8 +74,8 @@ export default class InsightFixRouting {
       }
 
       /*
-       * Strict opt-in — the column defaults to false, so unset/legacy rows
-       * never enqueue. Autonomous PR creation must never be default-on.
+       * Strictly === true — the column defaults to false, so unset/legacy
+       * rows never enqueue. New projects get it on from ProjectService.
        */
       if (project.enableInsightFixTasks !== true) {
         logger.debug(

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

@@ -29,16 +29,16 @@ import CaptureSpan from "../../../Telemetry/CaptureSpan";
  * 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
+ * Everything is switchable and quiet: only projects with enableAiInsights
+ * on (on for new projects) are scanned, insights never page and never
  * open incidents, and every layer (project, detector, insight) fails in
  * isolation — one broken tenant or sensor must not stop the sweep.
  */
 export default class InsightScanner {
   /*
-   * One scan tick across all opted-in projects. The flag query IS the gate:
-   * enableAiInsights defaults to false, so nothing runs for a project
-   * that never opted in. Runs as root with explicit projectId scoping
+   * One scan tick across all projects with AI Insights on. The flag query
+   * IS the gate: nothing runs for a project whose enableAiInsights is
+   * off. Runs as root with explicit projectId scoping
    * (monitor-worker precedent), not per-user ACL. Never throws — the cron
    * caller gets a clean resolve either way.
    */

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

@@ -24,8 +24,8 @@ import CaptureSpan from "../../../Telemetry/CaptureSpan";
  * daily token budget, retries, TTL expiry, stale sweeping) — this module
  * only owns the insight-specific gates, mirroring the posture of
  * AIInvestigationEngine.isEnabledForProject: enableAi not disabled,
- * the subject's own strict opt-in (Project.enableAiInsights, default
- * FALSE), and a configured LLM provider.
+ * the subject's own switch (Project.enableAiInsights, on for new
+ * projects), and a configured LLM provider.
  */
 
 export interface InsightTriageResult {
@@ -76,9 +76,10 @@ export default class InsightTriage {
       }
 
       /*
-       * Strict opt-in — the column defaults to false. A triage run only
-       * exists because insights exist, so it shares the insights flag; the
-       * fix-tasks flag is a separate, stricter opt-in.
+       * Strictly === true — the column defaults to false, so unset/legacy
+       * rows never enqueue. A triage run only exists because insights
+       * exist, so it shares the insights flag; the fix-tasks flag is a
+       * separate switch.
        */
       if (project.enableAiInsights !== true) {
         logger.debug(

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

@@ -14,9 +14,10 @@ import CaptureSpan from "../../Telemetry/CaptureSpan";
  * When an investigation finishes INCONCLUSIVE — per the structured G6
  * confidence signal (ConfidenceSignal.ts), never the analysis prose — the
  * telemetry itself is the bug: the code paths involved were not observable
- * enough to diagnose. For projects that opted in
- * (the subject lane's incident/alert instrumentation setting, default FALSE
- * — G11 posture: autonomous PR creation is opt-in only), the inconclusive analysis becomes
+ * enough to diagnose. For projects with the subject lane's incident/alert
+ * instrumentation setting on (on for new projects; a project that existed
+ * before keeps its own value, and unset reads as off), the inconclusive
+ * analysis becomes
  * the input to a CodeFix AIRun (codeFixTaskType: ImproveInstrumentation)
  * that the agent worker turns into a pull request adding the missing
  * observability — so the NEXT investigation of a similar signal can reach a
@@ -48,8 +49,8 @@ export interface InstrumentationTaskGateDecision {
 export default class InstrumentationTaskTrigger {
   /*
    * The pure trigger decision, separated from IO so it can be tested
-   * directly: opt-in (default FALSE), a repository the agent can actually
-   * open a PR against, and the per-subject dedupe guard.
+   * directly: the project's setting (=== true), a repository the agent
+   * can actually open a PR against, and the per-subject dedupe guard.
    */
   public static shouldEnqueueInstrumentationTask(
     input: InstrumentationTaskGateInput,
@@ -63,8 +64,8 @@ export default class InstrumentationTaskTrigger {
     }
 
     /*
-     * Strict opt-in — the column defaults to false, so unset/legacy rows
-     * never enqueue. Autonomous PR creation must never be default-on.
+     * Strictly === true — the column defaults to false, so unset/legacy
+     * rows never enqueue. New projects get it on from ProjectService.
      */
     if (Boolean(input.incidentId) === Boolean(input.alertId)) {
       return {

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

@@ -92,7 +92,7 @@ export default class InvestigationEligibility {
         title: recorded
           ? "Severity was below the investigation threshold at creation"
           : "Severity is below the current investigation threshold",
-        description: `${recorded ? `When this ${kind} was created, its` : `This ${kind}'s`}${details?.severityName ? ` ${details.severityName}` : ""} severity ${recorded ? "did not meet" : "does not meet"} ${details?.minimumSeverityName ? `the minimum ${details.minimumSeverityName} investigation severity` : "the configured investigation threshold"}.${kind === "alert" ? " By default, only the two highest alert severity tiers are investigated." : ""}`,
+        description: `${recorded ? `When this ${kind} was created, its` : `This ${kind}'s`}${details?.severityName ? ` ${details.severityName}` : ""} severity ${recorded ? "did not meet" : "does not meet"} ${details?.minimumSeverityName ? `the minimum ${details.minimumSeverityName} investigation severity` : "the configured investigation threshold"}.`,
         nextStep:
           "Review the minimum investigation severity in AI settings. Changes apply to new records and do not retry this record.",
       },

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

@@ -5,6 +5,7 @@ import Query from "../../../../Types/BaseDatabase/Query";
 import AIRunType from "../../../../Types/AI/AIRunType";
 import AIRunStatus from "../../../../Types/AI/AIRunStatus";
 import AIRunCodeFixRecommendation from "../../../../Types/AI/AIRunCodeFixRecommendation";
+import AIWorkloadLimits from "../../../../Types/AI/AIWorkloadLimits";
 import AIRun from "../../../../Models/DatabaseModels/AIRun";
 import Project from "../../../../Models/DatabaseModels/Project";
 import AIRunService from "../../../Services/AIRunService";
@@ -51,39 +52,31 @@ import InvestigationSubjectLock from "./InvestigationSubjectLock";
 export const MAX_INVESTIGATION_ATTEMPTS: number = 2;
 
 /*
- * G4 cost guardrail: at most this many investigations may be Running in an
- * incident, alert or subjectless lane at once. The incident and alert lanes
- * have their own project override; subjectless work always uses the default.
- * Enforced at CLAIM time, so a storm queues (bounded by dedupe + severity
- * gates + this TTL) and drains at cap rate instead of being dropped.
- */
-export const DEFAULT_MAX_CONCURRENT_INVESTIGATIONS: number = 3;
-/*
- * Clamp bounds for the per-project override. Pausing has its own switches
- * (the opt-in toggles, daily limit 0), so the floor is 1, not 0.
- */
-const MIN_CONCURRENT_INVESTIGATIONS: number = 1;
-const MAX_CONCURRENT_INVESTIGATIONS: number = 25;
-
-/*
- * Lane priority. Two kinds of run share this queue and each subject lane's
- * concurrency cap above:
- *   - the INTERACTIVE lane (incident/alert RCA) — a human is waiting;
- *   - the PREVENTIVE lane (AI-insight triage, identified by
- *     triggeredByAiInsightId) — nobody is waiting, and one scan tick
- *     can file up to MAX_NEW_INSIGHTS_PER_PROJECT_PER_SCAN (10) of them.
+ * G4 cost guardrail, opt-in: a project may cap how many runs go at once in
+ * its incident lane and in its alert lane (Incidents or Alerts → Settings →
+ * AI). Unset means no cap — a run is claimed as soon as it passes the budget
+ * gate, however many are already Running — and subjectless work (insight
+ * triage) has no setting and no cap (see AIWorkloadLimits). Where a cap is
+ * set it is enforced at CLAIM time, so a storm queues (bounded by
+ * QUEUE_TTL_MINUTES) and drains at cap rate instead of being dropped.
+ *
+ * Lane priority inside a capped lane. Two kinds of run share its slots:
+ *   - INTERACTIVE work (the incident/alert RCA) — a human is waiting;
+ *   - BACKGROUND work (remediation plans and executions; insight triage is
+ *     counted the same way, though its own lane has no cap) — nobody is
+ *     waiting, and it is storm-shaped.
  *
- * Without a sub-cap the preventive lane can hold every slot, and since the
- * poller drains oldest-first, an incident that fires after a scan queues
+ * Without a sub-cap background work can hold every slot, and since the
+ * poller drains oldest-first, an incident that fires after a burst queues
  * BEHIND that backlog — the exact RCA latency the product promises.
  *
- * So the preventive lane may hold at most (cap - RESERVED) slots: at least
- * one slot is always unreachable by triage. Combined with the inline kick
- * that enqueue() fires for every run, that reserved slot is enough on its
- * own — an incident/alert enqueue calls processRun immediately, passes the
- * gates against a cap that triage cannot have saturated, and dispatches
+ * So background work may hold at most (cap - RESERVED) slots: at least one
+ * slot is always unreachable by it. Combined with the inline kick that
+ * enqueue() fires for every run, that reserved slot is enough on its own —
+ * an incident/alert enqueue calls processRun immediately, passes the gates
+ * against a cap that background work cannot have saturated, and dispatches
  * without ever touching the poller (so it can also never be TTL-expired
- * behind triage). Splitting the poller's oldest-first query into two lane
+ * behind it). Splitting the poller's oldest-first query into two lane
  * queries would therefore only re-order runs that are ALREADY late, at the
  * cost of an extra query every tick — deliberately not done.
  */
@@ -92,7 +85,7 @@ export const INSIGHT_TRIAGE_RESERVED_SLOTS: number = 1;
 /*
  * A first-pass RCA is only useful while the incident is fresh. Queued runs
  * older than this are expired rather than run late — this also caps queue
- * growth when the daily budget blocks claiming for hours.
+ * growth when a configured cap or daily budget blocks claiming for hours.
  */
 export const QUEUE_TTL_MINUTES: number = 30;
 
@@ -293,7 +286,8 @@ export default class AIInvestigationQueue {
    * Claim a queued run and execute it to completion. Safe to call from
    * multiple places concurrently — the claim is one conditional UPDATE, so
    * exactly one caller wins. Leaves the run Queued (for the poller / TTL)
-   * when the concurrency cap is full or the budget is exhausted.
+   * when a concurrency cap the project set is full or the budget is
+   * exhausted.
    */
   @CaptureSpan()
   public static async processRun(run: QueuedRunRef): Promise<void> {
@@ -360,7 +354,7 @@ export default class AIInvestigationQueue {
           status: AIRunStatus.Cancelled,
           codeFixRecommendation: AIRunCodeFixRecommendation.NotRecommended,
           completedAt: OneUptimeDate.getCurrentDate(),
-          errorMessage: `Expired in the investigation queue after ${QUEUE_TTL_MINUTES} minutes — a first-pass analysis this late would no longer be useful. The project may have been at its concurrency cap or daily token budget.`,
+          errorMessage: `Expired in the investigation queue after ${QUEUE_TTL_MINUTES} minutes — a first-pass analysis this late would no longer be useful. The project may have been at a concurrency cap or daily token limit it set.`,
         },
       });
 
@@ -618,10 +612,10 @@ export default class AIInvestigationQueue {
   }
 
   /*
-   * The claim-time cost gates: concurrency cap, the preventive-lane sub-cap
-   * and the daily budget. A run failing these stays Queued — the poller
-   * retries and the TTL expires what never fits. Fails cheap (skip) on gate
-   * errors.
+   * The claim-time cost gates: the concurrency cap and the preventive-lane
+   * sub-cap (only when the lane has a cap), then the daily budget. A run
+   * failing these stays Queued — the poller retries and the TTL expires what
+   * never fits. Fails cheap (skip) on gate errors.
    */
   private static async passesClaimGates(run: QueuedRunRef): Promise<boolean> {
     if (run.triggeredByIncidentId && run.triggeredByAlertId) {
@@ -633,7 +627,7 @@ export default class AIInvestigationQueue {
 
     /*
      * Each subject lane owns its own concurrency pool. Insight triage and any
-     * future subjectless queue work use the default cap.
+     * future subjectless queue work have no setting, so no cap.
      */
     let configuredConcurrencyCap: number | undefined = undefined;
 
@@ -651,14 +645,41 @@ export default class AIInvestigationQueue {
         : project?.alertAiMaxConcurrentInvestigations;
     }
 
-    const concurrencyCap: number = Math.min(
-      MAX_CONCURRENT_INVESTIGATIONS,
-      Math.max(
-        MIN_CONCURRENT_INVESTIGATIONS,
-        configuredConcurrencyCap ?? DEFAULT_MAX_CONCURRENT_INVESTIGATIONS,
-      ),
-    );
+    const concurrencyCap: number | null =
+      AIWorkloadLimits.getMaxConcurrentInvestigations(configuredConcurrencyCap);
+
+    // No cap, nothing to count: the run is only held back by the budget.
+    if (
+      concurrencyCap !== null &&
+      !(await this.hasFreeSlot(run, concurrencyCap))
+    ) {
+      return false;
+    }
+
+    const budget: AutonomousBudgetStatus =
+      await AIService.getAutonomousDailyBudgetStatus(run.projectId, {
+        incidentId: run.triggeredByIncidentId,
+        alertId: run.triggeredByAlertId,
+      });
 
+    if (budget.exhausted) {
+      logger.debug(
+        `AI: leaving run ${run.id.toString()} queued — daily autonomous token budget exhausted.`,
+      );
+      return false;
+    }
+
+    return true;
+  }
+
+  /*
+   * Whether the run's lane has a slot free under the cap the project set for
+   * it, including the background lane's share of that cap.
+   */
+  private static async hasFreeSlot(
+    run: QueuedRunRef,
+    concurrencyCap: number,
+  ): Promise<boolean> {
     const subjectLaneQuery: Query<AIRun> = this.getSubjectLaneQuery(run);
 
     /*
@@ -756,19 +777,6 @@ export default class AIInvestigationQueue {
       }
     }
 
-    const budget: AutonomousBudgetStatus =
-      await AIService.getAutonomousDailyBudgetStatus(run.projectId, {
-        incidentId: run.triggeredByIncidentId,
-        alertId: run.triggeredByAlertId,
-      });
-
-    if (budget.exhausted) {
-      logger.debug(
-        `AI: leaving run ${run.id.toString()} queued — daily autonomous token budget exhausted.`,
-      );
-      return false;
-    }
-
     return true;
   }
 

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

@@ -74,7 +74,7 @@ export default class TelemetryImprovementTaskTrigger {
 
     if (!hasConnectedRepository) {
       throw new BadDataException(
-        "No GitHub-App-connected repository exists for this project, so the agent has nowhere to open the pull request. Connect one under AI > Code Repositories.",
+        "No GitHub-App-connected repository exists for this project, so the agent has nowhere to open the pull request. Connect one under Tasks > Code Repositories.",
       );
     }
 

package/Server/Utils/AI/Toolbox/AIActionTools.ts

@@ -130,7 +130,7 @@ export const PageOnCallPolicyTool: ObservabilityTool = {
     const policy: OnCallDutyPolicy | null =
       await OnCallDutyPolicyService.findOneById({
         id: policyId,
-        select: { _id: true, name: true },
+        select: { _id: true, name: true, isArchived: true },
         props: ctx.props,
       });
     if (!policy) {
@@ -138,6 +138,16 @@ export const PageOnCallPolicyTool: ObservabilityTool = {
         "On-call duty policy not found (or you do not have access to it).",
       );
     }
+    /*
+     * Refused here rather than left to executePolicy, which would record a
+     * skipped execution: this tool would then tell the user "responders are
+     * being notified" when nobody is.
+     */
+    if (policy.isArchived) {
+      throw new BadDataException(
+        `On-call duty policy "${policy.name}" is archived, so it pages no one. Unarchive it first, or page a different policy.`,
+      );
+    }
 
     const incident: Incident | null = await IncidentService.findOneById({
       id: incidentId,

package/Server/Utils/AI/Toolbox/AIMetaTools.ts

@@ -22,7 +22,6 @@ import AlertService from "../../../Services/AlertService";
 import QueryHelper from "../../../Types/Database/QueryHelper";
 import PostedRootCause from "../SRE/PostedRootCause";
 import AIInvestigationQueue from "../SRE/InvestigationQueue";
-import { DEFAULT_INCIDENT_DEDUPE_WINDOW_MINUTES } from "../SRE/IncidentInvestigationRunner";
 import ToolResultSerializer, { SerializedResult } from "./Serializer";
 import WidgetBuilder from "./WidgetBuilder";
 import {
@@ -50,6 +49,14 @@ import {
 // How many investigation runs one get_ai_investigation call returns at most.
 const MAX_INVESTIGATION_RUNS_RETURNED: number = 5;
 
+/*
+ * How recent a run on the exact same subject must be for start_investigation
+ * to point the model at it instead of starting another. This is the chat's
+ * duplicate guard, not the automatic lanes' per-monitor cooldown — that one
+ * is a project setting and off by default.
+ */
+const RECENT_INVESTIGATION_REUSE_WINDOW_MINUTES: number = 30;
+
 /*
  * Detects the analysis' own "the evidence was inconclusive" verdict in the
  * posted prose/TL;DR. Purely informational (the note tells the model to be
@@ -329,7 +336,7 @@ export const GetAIInvestigationTool: ObservabilityTool = {
 
     if (runs.length === 0) {
       return {
-        dataForLlm: `No AI investigation runs exist for ${subject.label}. The automatic gates may have skipped it (severity floor, dedupe window, the project's automatic-investigation opt-in, or the daily AI budget). You can offer to start one with start_investigation.`,
+        dataForLlm: `No AI investigation runs exist for ${subject.label}. The automatic gates may have skipped it (severity floor, dedupe window, the project's automatic-investigation setting being off, or the daily AI budget). You can offer to start one with start_investigation.`,
         rowCount: 0,
         citationLabel: `AI investigation for ${subject.label} (none found)`,
         citationTarget: {
@@ -765,13 +772,12 @@ export const StartInvestigationTool: ObservabilityTool = {
     }
 
     /*
-     * Cooldown: reuse the automatic lane's default dedupe window (30
-     * minutes). A run that recently settled for this exact subject already
-     * answered — or errored on — the same question; point the model at it
-     * instead of double-spending the budget.
+     * A run that recently settled for this exact subject already answered —
+     * or errored on — the same question; point the model at it instead of
+     * double-spending the budget.
      */
     const cooldownStart: Date = OneUptimeDate.getSomeMinutesAgo(
-      DEFAULT_INCIDENT_DEDUPE_WINDOW_MINUTES,
+      RECENT_INVESTIGATION_REUSE_WINDOW_MINUTES,
     );
     const recentRunCount: number = (
       await AIRunService.countBy({
@@ -786,7 +792,7 @@ export const StartInvestigationTool: ObservabilityTool = {
 
     if (recentRunCount > 0) {
       return {
-        dataForLlm: `A recent AI investigation already exists for ${subject.label} (started within the last ${DEFAULT_INCIDENT_DEDUPE_WINDOW_MINUTES} minutes) — not starting a duplicate. Read it with get_ai_investigation.`,
+        dataForLlm: `A recent AI investigation already exists for ${subject.label} (started within the last ${RECENT_INVESTIGATION_REUSE_WINDOW_MINUTES} minutes) — not starting a duplicate. Read it with get_ai_investigation.`,
         rowCount: 0,
         citationLabel: `Recent investigation exists for ${subject.label}`,
         citationTarget: {

package/Server/Utils/AI/Toolbox/MonitorTools.ts

@@ -32,6 +32,15 @@ import {
  * TypeError. By the time a tool actually executes, every module is loaded.
  */
 let cachedReadPermissions: Array<Permission> | null = null;
+
+/*
+ * An archived monitor is not monitored, so the status it shows is the one it
+ * had when it was archived. The list leaves archived monitors out (as the
+ * Monitors page does), so "what is down right now?" never names one; read by
+ * id, it is still returned, flagged, with this said alongside.
+ */
+export const ARCHIVED_MONITOR_NOTE: string =
+  "This monitor is archived: it is not being monitored, so its status is the one it had when it was archived. Unarchive it to monitor it again.";
 const resolveReadPermissions: () => Array<Permission> =
   (): Array<Permission> => {
     if (!cachedReadPermissions) {
@@ -43,7 +52,7 @@ const resolveReadPermissions: () => Array<Permission> =
 export const QueryMonitorsTool: ObservabilityTool = {
   name: "query_monitors",
   description:
-    "List monitors in this project with their current status (name and color). To answer 'which monitors are down / not operational right now?' pass problemsOnly=true — it returns only monitors whose current status is not an operational state. To list monitors in one specific status (e.g. 'Degraded' or 'Offline'), pass monitorStatusName (case-insensitive). Returned monitors are ordered problems-first (worst status first, then name); the result reports the total match count — pass skip to page through more. Pass monitorId to get one monitor's details, its owners (teams and users) and its recent status timeline (when it went up or down).",
+    "List monitors in this project with their current status (name and color). Archived monitors are left out of the list - they are not monitored; pass monitorId to read one. To answer 'which monitors are down / not operational right now?' pass problemsOnly=true — it returns only monitors whose current status is not an operational state. To list monitors in one specific status (e.g. 'Degraded' or 'Offline'), pass monitorStatusName (case-insensitive). Returned monitors are ordered problems-first (worst status first, then name); the result reports the total match count — pass skip to page through more. Pass monitorId to get one monitor's details, its owners (teams and users) and its recent status timeline (when it went up or down).",
   inputSchema: {
     type: "object",
     properties: {
@@ -96,6 +105,7 @@ export const QueryMonitorsTool: ObservabilityTool = {
           _id: true,
           name: true,
           monitorType: true,
+          isArchived: true,
           currentMonitorStatus: {
             name: true,
             color: true,
@@ -203,6 +213,7 @@ export const QueryMonitorsTool: ObservabilityTool = {
           statusColor: monitor.currentMonitorStatus?.color?.toString(),
           ownerTeams: ownerTeamNames || undefined,
           ownerUsers: ownerUserNames || undefined,
+          archived: monitor.isArchived === true ? true : undefined,
         });
       }
 
@@ -227,6 +238,9 @@ export const QueryMonitorsTool: ObservabilityTool = {
           value: monitor.currentMonitorStatus.name,
         });
       }
+      if (monitor?.isArchived === true) {
+        cardFields.push({ label: "Archived", value: "Yes - not monitored" });
+      }
       if (ownerTeamNames) {
         cardFields.push({ label: "Owner teams", value: ownerTeamNames });
       }
@@ -235,7 +249,10 @@ export const QueryMonitorsTool: ObservabilityTool = {
       }
 
       return {
-        dataForLlm: serialized.text,
+        dataForLlm:
+          monitor?.isArchived === true
+            ? `${ARCHIVED_MONITOR_NOTE}\n${serialized.text}`
+            : serialized.text,
         rowCount: serialized.rowCount,
         citationLabel: `Monitor ${monitor?.name || monitorId.toString()} + status timeline`,
         citationTarget: {
@@ -281,7 +298,8 @@ export const QueryMonitorsTool: ObservabilityTool = {
     const problemsOnly: boolean =
       ToolArgs.getBoolean(args, "problemsOnly") === true;
 
-    const query: Query<Monitor> = {};
+    // Archived monitors are not monitored: their status is stale.
+    const query: Query<Monitor> = { isArchived: false };
 
     if (nameSearch) {
       query.name = QueryHelper.search(nameSearch);