@oneuptime/common 14.0.8 → 14.0.10

package/Server/Services/KubernetesClusterService.ts

@@ -30,10 +30,7 @@ import { holdsAnyPermission } from "../Utils/Runbook/RunbookExecutePermission";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import BadDataException from "../../Types/Exception/BadDataException";
 import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
-import {
-  KubernetesAiRemediationMode,
-  isUnattendedRemediationMode,
-} from "../../Types/Kubernetes/KubernetesClusterAiAccess";
+import { KubernetesAiRemediationMode } from "../../Types/Kubernetes/KubernetesClusterAiAccess";
 import {
   KUBERNETES_AI_ACCESS_ADMIN_PERMISSIONS,
   KUBERNETES_AI_ACCESS_CREDENTIAL_PERMISSIONS,
@@ -41,6 +38,7 @@ import {
 import { PermissionHelper } from "../../Types/Permission";
 import RunbookCredentialType from "../../Types/Runbook/RunbookCredentialType";
 import KubernetesClusterFeedService from "./KubernetesClusterFeedService";
+import KubernetesAiAgentService from "./KubernetesAiAgentService";
 import { KubernetesClusterFeedEventType } from "../../Models/DatabaseModels/KubernetesClusterFeed";
 import ResourceFeedUtil from "../Utils/ResourceFeed/ResourceFeedUtil";
 import { Blue500, Gray500, Green500, Yellow500 } from "../../Types/BrandColors";
@@ -151,11 +149,11 @@ export const AI_ACCESS_CREDENTIAL_REFUSAL: string =
   "Credential not found, or it is not a Kubernetes credential in this project. The AI access credential must be a Kubernetes credential (API server URL and ServiceAccount token) that belongs to this project.";
 
 export function getAiAccessAdminRefusal(): string {
-  return `You need one of these permissions to let OneUptime AI do more on a Kubernetes cluster (switch AI remediation to Automatic or Bypass approval, add kubectl allowlist patterns, or bind a Runner or credential): ${PermissionHelper.getPermissionTitles(
+  return `You need one of these permissions to let OneUptime AI do more on a Kubernetes cluster (turn AI fixes on or give them more autonomy, add kubectl allowlist patterns, bind a Runner or credential, or clear one while the cluster has a Kubernetes AI agent): ${PermissionHelper.getPermissionTitles(
     KUBERNETES_AI_ACCESS_ADMIN_PERMISSIONS,
   ).join(
     ", ",
-  )}. Anyone who may edit the cluster can still turn AI remediation off or back to Ask for approval, remove allowlist patterns, and clear the Runner or credential.`;
+  )}. Anyone who may edit the cluster can still turn AI fixes off or down to Ask for approval, and remove allowlist patterns.`;
 }
 
 export function getAiAccessCredentialRefusal(): string {
@@ -183,11 +181,22 @@ export interface AiAccessSettingsSnapshot {
   aiKubectlCommandAllowlist: Array<string>;
   aiAccessRunnerId: string | null;
   aiAccessCredentialId: string | null;
+  /*
+   * Whether the cluster has a Kubernetes AI agent row. Read only for a
+   * write that clears the Runner or credential binding (absent otherwise):
+   * with an agent, clearing an advanced Runner hands the cluster to the
+   * agent, whose RBAC may reach more, so it is a loosening.
+   */
+  hasKubernetesAiAgent?: boolean | undefined;
 }
 
-// What a cluster that was never AI-configured has: the column defaults.
+/*
+ * What a cluster that was never AI-configured has: the column defaults
+ * (investigation on — it only ever runs read-only kubectl — and remediation
+ * Disabled).
+ */
 const NEVER_CONFIGURED_AI_ACCESS: AiAccessSettingsSnapshot = {
-  isAiInvestigationEnabled: false,
+  isAiInvestigationEnabled: true,
   aiRemediationMode: KubernetesAiRemediationMode.Disabled,
   aiKubectlCommandAllowlist: [],
   aiAccessRunnerId: null,
@@ -229,7 +238,7 @@ function getClusterDeleteCarryForward(
 }
 
 // What loosening an operator's write would do to one cluster.
-interface AiAccessLoosening {
+export interface AiAccessLoosening {
   loosens: boolean;
   bindsCredential: boolean;
 }
@@ -319,7 +328,9 @@ export class Service extends DatabaseService<Model> {
 
     if (!updateBy.props.isRoot && this.isAiAccessSettingWritten(data)) {
       const previousAiAccessSettings: Record<string, AiAccessSettingsSnapshot> =
-        await this.getAiAccessSettingsForUpdateQuery(updateBy);
+        await this.getAiAccessSettingsForUpdateQuery(updateBy, {
+          withKubernetesAiAgent: this.clearsAiAccessBinding(data),
+        });
 
       if (!updateBy.props.isMasterAdmin) {
         this.assertMayChangeAiAccess({
@@ -657,22 +668,29 @@ export class Service extends DatabaseService<Model> {
 
   /*
    * Does this write let AI do more on a cluster whose settings are
-   * `current`? Only a real change counts: the AI page posts every field of
-   * its form, so an editor who only flips the investigation switch re-posts
-   * an unchanged mode, allowlist and binding, and must not be refused for
-   * settings someone else chose.
+   * `current`? Only a real change counts: the AI agent page posts every
+   * field of its form, so an editor who only flips the investigation switch
+   * re-posts an unchanged mode, allowlist and binding, and must not be
+   * refused for settings someone else chose.
    *
-   * - mode: moving UP to Automatic or Bypass approval (Bypass approval ->
-   *   Automatic is a tightening);
+   * - mode: ANY move up — turning fixes on from Off (even to Ask for
+   *   approval: with the chart's write RBAC in place that is the step that
+   *   lets AI change the cluster at all, and no project opt-in stands behind
+   *   it any more for a cluster reached through its agent), or up to
+   *   Automatic or Bypass approval. Moving down (Bypass approval ->
+   *   Automatic, anything -> Off) tightens;
    * - allowlist: adding a pattern the cluster did not already have
    *   (removing patterns, or clearing the list, tightens);
-   * - Runner or credential: binding one other than the current one
-   *   (clearing tightens).
+   * - Runner or credential: binding one other than the current one; and
+   *   clearing one while the cluster has a Kubernetes AI agent, which hands
+   *   the cluster to the agent (resolveKubernetesAiAccessTarget) and its
+   *   RBAC. Without an agent, clearing leaves AI nothing to reach the
+   *   cluster through, and tightens.
    *
    * `data` has been through validateAiRemediationSettings, so the mode is a
    * known value and the allowlist a trimmed array or null.
    */
-  private getAiAccessLoosening(
+  public getAiAccessLoosening(
     data: JSONObject,
     current: AiAccessSettingsSnapshot,
   ): AiAccessLoosening {
@@ -685,7 +703,6 @@ export class Service extends DatabaseService<Model> {
 
     if (
       mode !== undefined &&
-      isUnattendedRemediationMode(mode) &&
       REMEDIATION_MODES_BY_AUTONOMY.indexOf(mode) >
         REMEDIATION_MODES_BY_AUTONOMY.indexOf(current.aiRemediationMode)
     ) {
@@ -729,9 +746,42 @@ export class Service extends DatabaseService<Model> {
       bindsCredential = true;
     }
 
+    if (current.hasKubernetesAiAgent === true) {
+      const clearsRunner: boolean =
+        isAnyKeyWritten(data, AI_ACCESS_RUNNER_KEYS) &&
+        !runnerId &&
+        current.aiAccessRunnerId !== null;
+      const clearsCredential: boolean =
+        isAnyKeyWritten(data, AI_ACCESS_CREDENTIAL_KEYS) &&
+        !credentialId &&
+        current.aiAccessCredentialId !== null;
+
+      if (clearsRunner || clearsCredential) {
+        loosens = true;
+      }
+    }
+
     return { loosens, bindsCredential };
   }
 
+  // The write clears the Runner or the credential binding (null).
+  private clearsAiAccessBinding(data: JSONObject): boolean {
+    return (
+      (isAnyKeyWritten(data, AI_ACCESS_RUNNER_KEYS) &&
+        !RelationIdUtil.readConsistent(
+          data,
+          AI_ACCESS_RUNNER_KEYS,
+          "AI access Runner",
+        )) ||
+      (isAnyKeyWritten(data, AI_ACCESS_CREDENTIAL_KEYS) &&
+        !RelationIdUtil.readConsistent(
+          data,
+          AI_ACCESS_CREDENTIAL_KEYS,
+          "AI access credential",
+        ))
+    );
+  }
+
   /*
    * The AI access settings of every cluster an operator's update reaches,
    * read before the write. onBeforeUpdate runs before the framework scopes
@@ -742,6 +792,10 @@ export class Service extends DatabaseService<Model> {
   @CaptureSpan()
   private async getAiAccessSettingsForUpdateQuery(
     updateBy: UpdateBy<Model>,
+    options: {
+      // Also read whether each cluster has a Kubernetes AI agent row.
+      withKubernetesAiAgent: boolean;
+    } = { withKubernetesAiAgent: false },
   ): Promise<Record<string, AiAccessSettingsSnapshot>> {
     const clusters: Array<Model> = await this.findBy({
       query: {
@@ -790,9 +844,63 @@ export class Service extends DatabaseService<Model> {
       };
     }
 
+    if (options.withKubernetesAiAgent) {
+      await this.readKubernetesAiAgentPresence(settings);
+    }
+
     return settings;
   }
 
+  /*
+   * Fill in hasKubernetesAiAgent on each snapshot, one query per project the
+   * write reaches. Fails closed: when the agent rows cannot be read, every
+   * cluster is treated as having one, so clearing a binding then needs the
+   * admin permissions rather than slipping through unchecked.
+   */
+  private async readKubernetesAiAgentPresence(
+    settings: Record<string, AiAccessSettingsSnapshot>,
+  ): Promise<void> {
+    const clusterIdsByProject: Map<string, Array<ObjectID>> = new Map<
+      string,
+      Array<ObjectID>
+    >();
+
+    for (const [clusterId, snapshot] of Object.entries(settings)) {
+      const projectId: string = snapshot.projectId?.toString() || "";
+      const clusterIds: Array<ObjectID> =
+        clusterIdsByProject.get(projectId) || [];
+      clusterIds.push(new ObjectID(clusterId));
+      clusterIdsByProject.set(projectId, clusterIds);
+    }
+
+    for (const [projectId, clusterIds] of clusterIdsByProject.entries()) {
+      let agentClusterIds: Set<string> | null = null;
+
+      if (projectId) {
+        try {
+          agentClusterIds = new Set<string>(
+            (
+              await KubernetesAiAgentService.findForClusters({
+                projectId: new ObjectID(projectId),
+                kubernetesClusterIds: clusterIds,
+              })
+            ).keys(),
+          );
+        } catch (error) {
+          logger.error(
+            `KubernetesClusterService: could not read the Kubernetes AI agents of project ${projectId}; treating every cluster as having one: ${error}`,
+          );
+        }
+      }
+
+      for (const clusterId of clusterIds) {
+        settings[clusterId.toString()]!.hasKubernetesAiAgent = agentClusterIds
+          ? agentClusterIds.has(clusterId.toString())
+          : true;
+      }
+    }
+  }
+
   /*
    * aiAccessRunnerId / aiAccessCredentialId are editable through ordinary
    * CRUD by every member who may edit a cluster, and nothing in the
@@ -977,7 +1085,7 @@ export class Service extends DatabaseService<Model> {
 
       if (isAgentRunner && !isThisClustersAgent && isRunnerChanged) {
         throw new BadDataException(
-          `Runner "${runner.name}" is the in-cluster Runner the Kubernetes agent chart installed on another cluster. Its ServiceAccount reaches only the cluster its pod runs in, and it is never given a credential, so it cannot run kubectl for this cluster. Install the in-cluster Runner on this cluster with --set aiAccess.enabled=true, or bind a Runner you created under Project Settings → Runners together with a Kubernetes credential for this cluster.`,
+          `Runner "${runner.name}" is the in-cluster Runner the Kubernetes agent chart installed on another cluster. Its ServiceAccount reaches only the cluster its pod runs in, and it is never given a credential, so it cannot run kubectl for this cluster. Leave the Runner empty to use this cluster's Kubernetes AI agent, or bind a Runner you created under Project Settings → Runners together with a Kubernetes credential for this cluster.`,
         );
       }
 

package/Server/Services/MetricRecordingRuleService.ts

@@ -1,10 +1,57 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/MetricRecordingRule";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import BadDataException from "../../Types/Exception/BadDataException";
+import SessionReplayBudgetMetricTypeUtil, {
+  SESSION_REPLAY_METRIC_NAME_PREFIX,
+} from "../../Utils/SessionReplay/SessionReplayBudgetMetricType";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /*
+   * A recording rule writes its output straight into the metric store, past
+   * OTLP ingest, so the reserved session replay names have to be refused
+   * here too: those series open budget incidents and are left out of
+   * telemetry billing by name, so nothing but the budget sweep may write
+   * them (see SessionReplayBudgetMetricTypeUtil.isReservedMetricName).
+   */
+  public static assertOutputMetricNameAllowed(name: unknown): void {
+    if (
+      typeof name === "string" &&
+      SessionReplayBudgetMetricTypeUtil.isReservedMetricName(name.trim())
+    ) {
+      throw new BadDataException(
+        `Metric names that start with "${SESSION_REPLAY_METRIC_NAME_PREFIX}" are reserved for OneUptime's session replay budget metrics. Choose another output metric name.`,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    Service.assertOutputMetricNameAllowed(createBy.data.outputMetricName);
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    // Only an update that sets the name can make it reserved.
+    Service.assertOutputMetricNameAllowed(
+      (updateBy.data as unknown as Record<string, unknown>)["outputMetricName"],
+    );
+
+    return { updateBy, carryForward: null };
+  }
 }
 
 export default new Service();

package/Server/Services/PodmanHostService.ts

@@ -3,7 +3,15 @@ import PodmanHostLabelRuleEngineService from "./PodmanHostLabelRuleEngineService
 import PodmanHostOwnerRuleEngineService from "./PodmanHostOwnerRuleEngineService";
 import Model from "../../Models/DatabaseModels/PodmanHost";
 import Label from "../../Models/DatabaseModels/Label";
-import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import ResourceAiAccessSettings, {
+  ResourceAiAccessFeedItem,
+} from "../Utils/AI/ResourceAccess/ResourceAiAccessSettings";
+import ResourceAiDeleteCleanup from "../Utils/AI/ResourceAccess/ResourceAiDeleteCleanup";
+import AiResourceType from "../../Types/ResourceAiAgent/AiResourceType";
 import PodmanHostFeedService from "./PodmanHostFeedService";
 import { PodmanHostFeedEventType } from "../../Models/DatabaseModels/PodmanHostFeed";
 import ResourceFeedUtil from "../Utils/ResourceFeed/ResourceFeedUtil";
@@ -472,6 +480,79 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  /*
+   * Deleting a Podman host settles its in-flight AI remediation rounds and
+   * removes its resource AI agent — read before the delete, done after it for
+   * the Podman hosts actually deleted (ResourceAiDeleteCleanup, shared by every
+   * resource AI agent's resource).
+   */
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    return {
+      deleteBy,
+      carryForward: await ResourceAiDeleteCleanup.beforeDelete({
+        resourceType: AiResourceType.PodmanHost,
+        service: this,
+        deleteBy,
+      }),
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    deletedItemIds: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    await ResourceAiDeleteCleanup.afterDelete({
+      resourceType: AiResourceType.PodmanHost,
+      onDelete,
+      deletedItemIds,
+    });
+
+    return onDelete;
+  }
+
+  /*
+   * A create is held to the same AI access rules as an update, judged
+   * against the never-configured defaults a new Podman host starts from: an
+   * unusable mode or allowlist is refused for every caller, and the
+   * server-only aiAccess* columns for every caller but root (a master admin
+   * included, whom the create column ACLs never check).
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    ResourceAiAccessSettings.checkCreate({
+      resourceType: AiResourceType.PodmanHost,
+      createBy,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  /*
+   * An operator's write of an AI access setting (the investigation switch, the
+   * remediation mode, the command allowlist) is validated and checked against
+   * who may make AI do more on this Podman host — the rules every resource AI
+   * agent's resource shares (ResourceAiAccessSettings).
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    return {
+      updateBy,
+      carryForward: await ResourceAiAccessSettings.checkUpdate({
+        resourceType: AiResourceType.PodmanHost,
+        service: this,
+        updateBy,
+      }),
+    };
+  }
+
   @CaptureSpan()
   protected override async onUpdateSuccess(
     onUpdate: OnUpdate<Model>,
@@ -483,6 +564,33 @@ export class Service extends DatabaseService<Model> {
       },
     );
 
+    /*
+     * An operator's AI access write: recorded on the feed, and the Podman host
+     * marked AI-configured.
+     */
+    await ResourceAiAccessSettings.afterUpdate({
+      service: this,
+      onUpdate,
+      updatedItemIds,
+      getResourceMarkdownLink: (
+        projectId: ObjectID,
+        podmanHostId: ObjectID,
+      ): Promise<string> => {
+        return this.getPodmanHostMarkdownLink(projectId, podmanHostId);
+      },
+      createFeedItem: async (item: ResourceAiAccessFeedItem): Promise<void> => {
+        await PodmanHostFeedService.createPodmanHostFeedItem({
+          podmanHostId: item.resourceId,
+          projectId: item.projectId,
+          podmanHostFeedEventType: PodmanHostFeedEventType.PodmanHostUpdated,
+          displayColor: item.displayColor,
+          feedInfoInMarkdown: item.feedInfoInMarkdown,
+          moreInformationInMarkdown: item.moreInformationInMarkdown,
+          userId: item.userId,
+        });
+      },
+    });
+
     return onUpdate;
   }
 

package/Server/Services/ProjectService.ts

@@ -554,9 +554,41 @@ export class ProjectService extends DatabaseService<Model> {
       data.data.alertEpisodeNumberPrefix = "AE-";
     }
 
+    this.applyNewProjectAiDefaults(data.data);
+
     return Promise.resolve({ createBy: data, carryForward: null });
   }
 
+  /*
+   * A new project starts with AI investigating its incidents and alerts:
+   * both automatic-investigation opt-ins are turned on unless the create
+   * request set them itself (a request that says false keeps false). The
+   * columns' database default stays false, so projects that existed before
+   * this are never switched on by an upgrade, and a create that bypasses
+   * this hook entirely gets the old behaviour rather than a surprise.
+   *
+   * Postmortem drafting is deliberately NOT turned on here: it is its own
+   * opt-in (enableAutomaticPostmortemDraft), off by default.
+   */
+  public applyNewProjectAiDefaults(data: {
+    enableAutomaticIncidentInvestigation?: boolean | null | undefined;
+    enableAutomaticAlertInvestigation?: boolean | null | undefined;
+  }): void {
+    if (
+      data.enableAutomaticIncidentInvestigation === undefined ||
+      data.enableAutomaticIncidentInvestigation === null
+    ) {
+      data.enableAutomaticIncidentInvestigation = true;
+    }
+
+    if (
+      data.enableAutomaticAlertInvestigation === undefined ||
+      data.enableAutomaticAlertInvestigation === null
+    ) {
+      data.enableAutomaticAlertInvestigation = true;
+    }
+  }
+
   /*
    * Session replay is gated on the project's org-wide allow flag, and the
    * ingest gate caches the resolved policy per pod. Turning the flag off has

package/Server/Services/ProxmoxClusterService.ts

@@ -3,7 +3,15 @@ import ProxmoxClusterLabelRuleEngineService from "./ProxmoxClusterLabelRuleEngin
 import ProxmoxClusterOwnerRuleEngineService from "./ProxmoxClusterOwnerRuleEngineService";
 import Model from "../../Models/DatabaseModels/ProxmoxCluster";
 import Label from "../../Models/DatabaseModels/Label";
-import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import ResourceAiAccessSettings, {
+  ResourceAiAccessFeedItem,
+} from "../Utils/AI/ResourceAccess/ResourceAiAccessSettings";
+import ResourceAiDeleteCleanup from "../Utils/AI/ResourceAccess/ResourceAiDeleteCleanup";
+import AiResourceType from "../../Types/ResourceAiAgent/AiResourceType";
 import ProxmoxClusterFeedService from "./ProxmoxClusterFeedService";
 import { ProxmoxClusterFeedEventType } from "../../Models/DatabaseModels/ProxmoxClusterFeed";
 import ResourceFeedUtil from "../Utils/ResourceFeed/ResourceFeedUtil";
@@ -485,6 +493,79 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  /*
+   * Deleting a Proxmox cluster settles its in-flight AI remediation rounds and
+   * removes its resource AI agent — read before the delete, done after it for
+   * the Proxmox clusters actually deleted (ResourceAiDeleteCleanup, shared by
+   * every resource AI agent's resource).
+   */
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    return {
+      deleteBy,
+      carryForward: await ResourceAiDeleteCleanup.beforeDelete({
+        resourceType: AiResourceType.ProxmoxCluster,
+        service: this,
+        deleteBy,
+      }),
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    deletedItemIds: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    await ResourceAiDeleteCleanup.afterDelete({
+      resourceType: AiResourceType.ProxmoxCluster,
+      onDelete,
+      deletedItemIds,
+    });
+
+    return onDelete;
+  }
+
+  /*
+   * A create is held to the same AI access rules as an update, judged
+   * against the never-configured defaults a new Proxmox cluster starts from: an
+   * unusable mode or allowlist is refused for every caller, and the
+   * server-only aiAccess* columns for every caller but root (a master admin
+   * included, whom the create column ACLs never check).
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    ResourceAiAccessSettings.checkCreate({
+      resourceType: AiResourceType.ProxmoxCluster,
+      createBy,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  /*
+   * An operator's write of an AI access setting (the investigation switch, the
+   * remediation mode, the command allowlist) is validated and checked against
+   * who may make AI do more on this Proxmox cluster — the rules every resource
+   * AI agent's resource shares (ResourceAiAccessSettings).
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    return {
+      updateBy,
+      carryForward: await ResourceAiAccessSettings.checkUpdate({
+        resourceType: AiResourceType.ProxmoxCluster,
+        service: this,
+        updateBy,
+      }),
+    };
+  }
+
   @CaptureSpan()
   protected override async onUpdateSuccess(
     onUpdate: OnUpdate<Model>,
@@ -496,6 +577,34 @@ export class Service extends DatabaseService<Model> {
       },
     );
 
+    /*
+     * An operator's AI access write: recorded on the feed, and the Proxmox
+     * cluster marked AI-configured.
+     */
+    await ResourceAiAccessSettings.afterUpdate({
+      service: this,
+      onUpdate,
+      updatedItemIds,
+      getResourceMarkdownLink: (
+        projectId: ObjectID,
+        proxmoxClusterId: ObjectID,
+      ): Promise<string> => {
+        return this.getProxmoxClusterMarkdownLink(projectId, proxmoxClusterId);
+      },
+      createFeedItem: async (item: ResourceAiAccessFeedItem): Promise<void> => {
+        await ProxmoxClusterFeedService.createProxmoxClusterFeedItem({
+          proxmoxClusterId: item.resourceId,
+          projectId: item.projectId,
+          proxmoxClusterFeedEventType:
+            ProxmoxClusterFeedEventType.ProxmoxClusterUpdated,
+          displayColor: item.displayColor,
+          feedInfoInMarkdown: item.feedInfoInMarkdown,
+          moreInformationInMarkdown: item.moreInformationInMarkdown,
+          userId: item.userId,
+        });
+      },
+    });
+
     return onUpdate;
   }