@oneuptime/common 14.0.8 → 14.0.9

package/Tests/Server/Utils/AI/InvestigationEligibility.test.ts

@@ -18,6 +18,7 @@ import Project from "../../../../Models/DatabaseModels/Project";
 import AIRun from "../../../../Models/DatabaseModels/AIRun";
 import LlmProvider from "../../../../Models/DatabaseModels/LlmProvider";
 import ObjectID from "../../../../Types/ObjectID";
+import logger from "../../../../Server/Utils/Logger";
 import InvestigationNotStartedReason, {
   InvestigationNotStartedCode,
 } from "../../../../Types/AI/InvestigationNotStartedReason";
@@ -33,6 +34,7 @@ const codes: Array<InvestigationNotStartedCode> = [
   "ai_disabled",
   "automatic_investigation_disabled",
   "provider_missing",
+  "insufficient_ai_balance",
   "severity_below_threshold",
   "monitor_cooldown",
   "daily_budget_exhausted",
@@ -45,9 +47,29 @@ const configurationCodes: Array<InvestigationNotStartedCode> = [
   "ai_disabled",
   "automatic_investigation_disabled",
   "provider_missing",
+  "insufficient_ai_balance",
   "severity_below_threshold",
 ];
 
+const BALANCE_BLOCKER: string =
+  "This project is out of AI credits. Add credits under Project Settings → AI Credits, or turn on auto-recharge.";
+
+/*
+ * AIService.getAiBalanceBlocker — the one AI balance predicate shared with
+ * the Kubernetes cluster's ai_balance_insufficient gap. null = no blocker.
+ */
+function mockBalanceBlocker(
+  outcome: string | null | Error = null,
+): jest.SpyInstance {
+  const spy: jest.SpyInstance = jest.spyOn(AIService, "getAiBalanceBlocker");
+  if (outcome instanceof Error) {
+    spy.mockRejectedValue(outcome);
+  } else {
+    spy.mockResolvedValue(outcome);
+  }
+  return spy;
+}
+
 afterEach(() => {
   jest.restoreAllMocks();
 });
@@ -143,6 +165,7 @@ describe("investigation enablement reasons", () => {
     jest
       .spyOn(LlmProviderService, "getLLMProviderForProject")
       .mockResolvedValue(new LlmProvider());
+    mockBalanceBlocker(null);
     expect(
       await AIInvestigationEngine.getDisabledReason(projectId, "Incident"),
     ).toBeNull();
@@ -158,6 +181,256 @@ describe("investigation enablement reasons", () => {
   });
 });
 
+/*
+ * On OneUptime's own billed provider, a project with no AI credits (and
+ * auto-recharge off) has every model call refused with "Insufficient AI
+ * balance". Starting an investigation then only produces a failed run that
+ * is retried once, with nothing on the incident saying why — so the gate
+ * refuses up front with a reason people can act on. It is the same
+ * predicate as the cluster's ai_balance_insufficient gap, and it fails OPEN:
+ * the model call still enforces the balance.
+ */
+describe("the AI balance gate (insufficient_ai_balance)", () => {
+  function mockReadyProject(): jest.SpyInstance {
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(enabledProject());
+    return jest
+      .spyOn(LlmProviderService, "getLLMProviderForProject")
+      .mockResolvedValue(new LlmProvider());
+  }
+
+  it.each(["Alert", "Incident"] as const)(
+    "refuses a %s investigation when the project is out of AI credits",
+    async (kind: "Alert" | "Incident") => {
+      mockReadyProject();
+      mockBalanceBlocker(BALANCE_BLOCKER);
+
+      expect(
+        await AIInvestigationEngine.getDisabledReason(projectId, kind),
+      ).toBe("insufficient_ai_balance");
+      expect(
+        await AIInvestigationEngine.isEnabledForProject(projectId, kind),
+      ).toBe(false);
+    },
+  );
+
+  it("asks the shared predicate about this project, handing it the provider it already resolved", async () => {
+    const llmProvider: LlmProvider = new LlmProvider();
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(enabledProject());
+    const providerLookup: jest.SpyInstance = jest
+      .spyOn(LlmProviderService, "getLLMProviderForProject")
+      .mockResolvedValue(llmProvider);
+    const blocker: jest.SpyInstance = mockBalanceBlocker(null);
+
+    await AIInvestigationEngine.getDisabledReason(projectId, "Incident");
+
+    expect(blocker).toHaveBeenCalledTimes(1);
+    expect(blocker).toHaveBeenCalledWith({ projectId, llmProvider });
+    // One provider lookup for the whole gate, not one per check.
+    expect(providerLookup).toHaveBeenCalledTimes(1);
+  });
+
+  it("lets the investigation start when there is no blocker", async () => {
+    mockReadyProject();
+    mockBalanceBlocker(null);
+
+    expect(
+      await AIInvestigationEngine.getDisabledReason(projectId, "Alert"),
+    ).toBeNull();
+  });
+
+  it("an empty blocker string is not a blocker", async () => {
+    mockReadyProject();
+    mockBalanceBlocker("");
+
+    expect(
+      await AIInvestigationEngine.getDisabledReason(projectId, "Alert"),
+    ).toBeNull();
+  });
+
+  it("fails OPEN when the balance cannot be read — logged, never blocking", async () => {
+    mockReadyProject();
+    mockBalanceBlocker(new Error("billing store unavailable"));
+    const errorLog: jest.SpyInstance = jest
+      .spyOn(logger, "error")
+      .mockImplementation((): void => {
+        return undefined;
+      });
+
+    expect(
+      await AIInvestigationEngine.getDisabledReason(projectId, "Incident"),
+    ).toBeNull();
+    expect(errorLog).toHaveBeenCalledWith(
+      expect.stringContaining("could not check the AI balance"),
+    );
+  });
+
+  it.each([
+    ["AI is off", { enableAi: false }, "ai_disabled"],
+    [
+      "automatic investigation is off",
+      { enableAutomaticIncidentInvestigation: false },
+      "automatic_investigation_disabled",
+    ],
+  ] as const)(
+    "is not consulted when %s — the switch is the reason, not the balance",
+    async (
+      _label: string,
+      overrides: Partial<Project>,
+      expected: InvestigationNotStartedCode,
+    ) => {
+      jest
+        .spyOn(ProjectService, "findOneById")
+        .mockResolvedValue(Object.assign(enabledProject(), overrides));
+      const blocker: jest.SpyInstance = mockBalanceBlocker(BALANCE_BLOCKER);
+
+      expect(
+        await AIInvestigationEngine.getDisabledReason(projectId, "Incident"),
+      ).toBe(expected);
+      expect(blocker).not.toHaveBeenCalled();
+    },
+  );
+
+  it("is not consulted without a provider — a missing provider is the reason", async () => {
+    jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(enabledProject());
+    jest
+      .spyOn(LlmProviderService, "getLLMProviderForProject")
+      .mockResolvedValue(null);
+    const blocker: jest.SpyInstance = mockBalanceBlocker(BALANCE_BLOCKER);
+
+    expect(
+      await AIInvestigationEngine.getDisabledReason(projectId, "Alert"),
+    ).toBe("provider_missing");
+    expect(blocker).not.toHaveBeenCalled();
+  });
+
+  describe("getProviderOrBalanceReason — the half of the gate that is not a switch", () => {
+    it("reports a missing provider first", async () => {
+      jest
+        .spyOn(LlmProviderService, "getLLMProviderForProject")
+        .mockResolvedValue(null);
+      const blocker: jest.SpyInstance = mockBalanceBlocker(BALANCE_BLOCKER);
+
+      expect(
+        await AIInvestigationEngine.getProviderOrBalanceReason(projectId),
+      ).toBe("provider_missing");
+      expect(blocker).not.toHaveBeenCalled();
+    });
+
+    it("reports an empty balance", async () => {
+      jest
+        .spyOn(LlmProviderService, "getLLMProviderForProject")
+        .mockResolvedValue(new LlmProvider());
+      mockBalanceBlocker(BALANCE_BLOCKER);
+
+      expect(
+        await AIInvestigationEngine.getProviderOrBalanceReason(projectId),
+      ).toBe("insufficient_ai_balance");
+    });
+
+    it("reports nothing when a model can be called and paid for", async () => {
+      jest
+        .spyOn(LlmProviderService, "getLLMProviderForProject")
+        .mockResolvedValue(new LlmProvider());
+      mockBalanceBlocker(null);
+
+      expect(
+        await AIInvestigationEngine.getProviderOrBalanceReason(projectId),
+      ).toBeNull();
+    });
+
+    it("never reads the project's switches — callers own those", async () => {
+      jest
+        .spyOn(LlmProviderService, "getLLMProviderForProject")
+        .mockResolvedValue(new LlmProvider());
+      mockBalanceBlocker(null);
+      const projectRead: jest.SpyInstance = jest.spyOn(
+        ProjectService,
+        "findOneById",
+      );
+
+      await AIInvestigationEngine.getProviderOrBalanceReason(projectId);
+
+      expect(projectRead).not.toHaveBeenCalled();
+    });
+  });
+
+  it.each(subjects)(
+    "explains the recorded reason in plain words for %o",
+    (subject: InvestigationSubject) => {
+      const reason: InvestigationNotStartedReason =
+        InvestigationEligibility.reason("insufficient_ai_balance", subject);
+
+      expect(reason.code).toBe("insufficient_ai_balance");
+      expect(reason.title).toBe(
+        "The project was out of AI credits at creation",
+      );
+      expect(reason.description).toBe(
+        `This project had no AI credits left when this ${
+          subject.alertId ? "alert" : "incident"
+        } was created, so its automatic investigation did not start.`,
+      );
+      expect(reason.nextStep).toContain("Project Settings → AI Credits");
+      expect(reason.nextStep).toContain("auto-recharge");
+    },
+  );
+
+  it.each(subjects)(
+    "explains the current condition, pointing at AI Credits, for %o",
+    async (subject: InvestigationSubject) => {
+      mockMissingDecision();
+      jest
+        .spyOn(AIInvestigationEngine, "getDisabledReason")
+        .mockResolvedValue("insufficient_ai_balance");
+
+      const reason: InvestigationNotStartedReason =
+        await InvestigationEligibility.getNotStartedReason(subject);
+
+      expect(reason.code).toBe("insufficient_ai_balance");
+      expect(reason.source).toBe("current_configuration");
+      expect(reason.title).toBe("The project is currently out of AI credits");
+      expect(reason.nextStep).toContain(
+        "Add AI credits under Project Settings → AI Credits",
+      );
+      expect(reason.nextStep).toContain("auto-recharge");
+      // The subject gate and the daily budget are never reached.
+      expect(
+        AIAlertInvestigationRunner.shouldInvestigateAlert,
+      ).not.toHaveBeenCalled();
+      expect(
+        AIIncidentInvestigationRunner.shouldInvestigateIncident,
+      ).not.toHaveBeenCalled();
+      expect(AIService.getAutonomousDailyBudgetStatus).not.toHaveBeenCalled();
+    },
+  );
+});
+
+describe("the AI switches page is named where AI is off", () => {
+  it.each(subjects)(
+    "recorded and current ai_disabled next steps name Project Settings → AI Features for %o",
+    async (subject: InvestigationSubject) => {
+      const recorded: InvestigationNotStartedReason =
+        InvestigationEligibility.reason("ai_disabled", subject);
+      expect(recorded.nextStep).toContain("Project Settings → AI Features");
+      expect(recorded.nextStep).not.toContain("AI Credits");
+
+      mockMissingDecision();
+      jest
+        .spyOn(AIInvestigationEngine, "getDisabledReason")
+        .mockResolvedValue("ai_disabled");
+      const current: InvestigationNotStartedReason =
+        await InvestigationEligibility.getNotStartedReason(subject);
+      expect(current.nextStep).toContain("Project Settings → AI Features");
+      expect(current.nextStep).not.toContain("AI Credits");
+    },
+  );
+});
+
 describe.each(subjects)(
   "recorded explanation time context for %o",
   (subject: InvestigationSubject) => {
@@ -296,6 +569,7 @@ describe.each(subjects)(
       "ai_disabled",
       "automatic_investigation_disabled",
       "provider_missing",
+      "insufficient_ai_balance",
     ] as const)(
       "labels %s as current conditions, never historical proof",
       async (code: InvestigationNotStartedCode) => {
@@ -502,6 +776,7 @@ describe.each(subjects)(
       "ai_disabled",
       "automatic_investigation_disabled",
       "provider_missing",
+      "insufficient_ai_balance",
     ] as const)(
       "records disabled admission %s",
       async (code: InvestigationNotStartedCode) => {
@@ -593,6 +868,41 @@ describe.each(subjects)(
       ).not.toHaveBeenCalled();
       expect(AIInvestigationQueue.processRun).toHaveBeenCalled();
     });
+    it("records an empty AI balance through the real engine gate and never creates a run", async () => {
+      (
+        AIInvestigationEngine.getDisabledReason as unknown as jest.SpyInstance
+      ).mockRestore();
+      jest
+        .spyOn(ProjectService, "findOneById")
+        .mockResolvedValue(enabledProject());
+      jest
+        .spyOn(LlmProviderService, "getLLMProviderForProject")
+        .mockResolvedValue(new LlmProvider());
+      mockBalanceBlocker(BALANCE_BLOCKER);
+
+      expect(await trigger(subject)).toBe(false);
+      expectRecorded("insufficient_ai_balance");
+      expect(AIRunService.create).not.toHaveBeenCalled();
+      expect(AIInvestigationQueue.processRun).not.toHaveBeenCalled();
+    });
+    it("still starts the investigation through the real engine gate when the balance cannot be read", async () => {
+      (
+        AIInvestigationEngine.getDisabledReason as unknown as jest.SpyInstance
+      ).mockRestore();
+      jest
+        .spyOn(ProjectService, "findOneById")
+        .mockResolvedValue(enabledProject());
+      jest
+        .spyOn(LlmProviderService, "getLLMProviderForProject")
+        .mockResolvedValue(new LlmProvider());
+      mockBalanceBlocker(new Error("billing store unavailable"));
+      jest.spyOn(logger, "error").mockImplementation((): void => {
+        return undefined;
+      });
+
+      expect(await trigger(subject)).toBe(true);
+      expect(AIRunService.create).toHaveBeenCalled();
+    });
     it("records unexpected eligibility failures without stranding remediation", async () => {
       jest
         .spyOn(AIInvestigationEngine, "getDisabledReason")

package/Tests/Server/Utils/AI/KubectlInvestigationToolkit.test.ts

@@ -91,6 +91,8 @@ function readyCluster(
       posture: { inCluster: true, allowWrites: false },
     },
     accessMethod: "in_cluster",
+    aiAgent: null,
+    automaticInvestigation: { incidents: false, alerts: false },
     kubectlAllowlist: [],
     isInvestigationEnabled: true,
     isInvestigationReady: true,
@@ -1248,6 +1250,74 @@ describe("KubectlInvestigationToolkit run_kubectl when kubectl never ran", () =>
     expect(toolkit.getCommandsRun()).toBe(1);
   });
 
+  /*
+   * The same unclaimed command on a cluster reached through its Kubernetes
+   * AI agent: the text names the agent, never "its Runner".
+   */
+  it("names the Kubernetes AI agent, not a Runner, when the agent left the command unclaimed", async () => {
+    const toolkit: KubectlInvestigationToolkit =
+      new KubectlInvestigationToolkit({
+        projectId: PROJECT_ID,
+        aiRunId: RUN_ID,
+        clusters: [
+          readyCluster({
+            runner: {
+              id: RUNNER_ID.toString(),
+              name: "Kubernetes AI agent",
+              kind: "ai_agent",
+              isOnline: true,
+              canRunAiCommands: true,
+              posture: { inCluster: true, allowWrites: false },
+            },
+          }),
+        ],
+      });
+
+    const before: ToolCallOutcome = await getTool(
+      toolkit,
+      LIST_CLUSTER_ACCESS_TOOL_NAME,
+    ).execute({});
+    expect(before.textForLlm).toContain(
+      "read-only kubectl via the Kubernetes AI agent",
+    );
+
+    const outcome: ToolCallOutcome = await runOn(toolkit);
+
+    expect(outcome.errorMessage).toBe(
+      'kubectl was not run on cluster "prod-us": its Kubernetes AI agent did not pick up the command in time.',
+    );
+    expect(outcome.textForLlm).toContain(
+      "its Kubernetes AI agent did not pick up",
+    );
+    expect(outcome.textForLlm).toContain(
+      "the cluster's Kubernetes AI agent did not respond",
+    );
+    expect(outcome.textForLlm).not.toContain("Runner");
+
+    // The breaker speaks of the agent too.
+    const second: ToolCallOutcome = await runOn(toolkit);
+    expect(second.textForLlm).toMatch(/^The Kubernetes AI agent, which serves/);
+    expect(second.errorMessage).toBe(
+      'kubectl was not run on cluster "prod-us": its Kubernetes AI agent did not pick up an earlier command, so the cluster was unreachable for the rest of this investigation.',
+    );
+
+    const list: ToolCallOutcome = await getTool(
+      toolkit,
+      LIST_CLUSTER_ACCESS_TOOL_NAME,
+    ).execute({});
+    expect(list.textForLlm).toContain(
+      "its Kubernetes AI agent did not pick up an earlier command",
+    );
+
+    // The command went to the agent's row id with no credential.
+    const data: Record<string, unknown> = enqueue.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >;
+    expect(String(data["targetAgentId"])).toBe(RUNNER_ID.toString());
+    expect(data["credentialId"]).toBeUndefined();
+  });
+
   it("trips a per-cluster breaker: the next command fails at once, enqueues nothing and spends nothing", async () => {
     const toolkit: KubectlInvestigationToolkit = singleClusterToolkit();
 

package/Tests/Server/Utils/AI/KubectlJobRunnerFinishedJob.test.ts

@@ -230,6 +230,64 @@ describe("KubectlJobRunner.readFinishedJob", () => {
   });
 });
 
+/*
+ * A job enqueued for the cluster's Kubernetes AI agent (the row carries
+ * targetKubernetesAiAgentId) is worded for the agent: "Runner" would send
+ * the operator looking for a Runner that does not exist.
+ */
+describe("KubectlJobRunner.readFinishedJob for a Kubernetes AI agent job", () => {
+  function readAgentJob(terminalJob: RunnerJob): Promise<KubectlJobOutcome> {
+    return KubectlJobRunner.readFinishedJob({
+      job: {
+        ...enqueuedJob({ displayCommand: "kubectl get pods -n web" }),
+        targetKubernetesAiAgentId: ObjectID.generate(),
+      } as unknown as RunnerJob,
+      terminalJob,
+      command: "kubectl get pods -n web",
+      claimTimeoutInMs: KUBECTL_CLAIM_TIMEOUT_MS,
+      executionTimeoutInMs: EXECUTION_TIMEOUT_MS,
+    });
+  }
+
+  it("never picked up: names the agent", async () => {
+    claimRead.mockResolvedValue(terminal({}));
+
+    const outcome: KubectlJobOutcome = await readAgentJob(
+      terminal({ status: RunnerJobStatus.TimedOut }),
+    );
+
+    expect(outcome.errorMessage).toMatch(
+      /^The cluster's Kubernetes AI agent did not pick up this kubectl command within \d+s/,
+    );
+    expect(outcome.runState).toBe(KubectlRunState.NotRun);
+  });
+
+  it("taken and gone silent: names the agent", async () => {
+    claimRead.mockResolvedValue(terminal({ claimedAt: new Date() }));
+
+    const outcome: KubectlJobOutcome = await readAgentJob(
+      terminal({ status: RunnerJobStatus.TimedOut }),
+    );
+
+    expect(outcome.errorMessage).toMatch(
+      /^The Kubernetes AI agent took this kubectl command but did not report a result in time/,
+    );
+    expect(outcome.errorMessage).not.toContain("Runner");
+  });
+
+  it("claim unreadable: names the agent", async () => {
+    claimRead.mockRejectedValue(new Error("db down"));
+
+    const outcome: KubectlJobOutcome = await readAgentJob(
+      terminal({ status: RunnerJobStatus.TimedOut }),
+    );
+
+    expect(outcome.errorMessage).toContain(
+      "whether the Kubernetes AI agent picked it up could not be read",
+    );
+  });
+});
+
 describe("KubectlJobRunner.recordOutcomeOnCluster", () => {
   let recordOutcome: jest.SpyInstance;
 

package/Tests/Server/Utils/AI/RemediationCommandToolsKubectl.test.ts

@@ -107,6 +107,8 @@ function cluster(
       posture: { inCluster: true, allowWrites: true },
     },
     accessMethod: "in_cluster",
+    aiAgent: null,
+    automaticInvestigation: { incidents: false, alerts: false },
     kubectlAllowlist: [],
     isInvestigationEnabled: true,
     isInvestigationReady: true,

package/Tests/Server/Utils/AI/RemediationCommandToolsKubectlOutcome.test.ts

@@ -79,6 +79,8 @@ function cluster(): KubernetesClusterAiAccessStatus {
       posture: { inCluster: true, allowWrites: true },
     },
     accessMethod: "in_cluster",
+    aiAgent: null,
+    automaticInvestigation: { incidents: false, alerts: false },
     kubectlAllowlist: [],
     isInvestigationEnabled: true,
     isInvestigationReady: true,

package/Tests/Server/Utils/AI/RemediationCommandToolsLiveCluster.test.ts

@@ -103,6 +103,8 @@ function cluster(
       posture: { inCluster: true, allowWrites: true },
     },
     accessMethod: "in_cluster",
+    aiAgent: null,
+    automaticInvestigation: { incidents: false, alerts: false },
     kubectlAllowlist: [],
     isInvestigationEnabled: true,
     isInvestigationReady: true,

package/Tests/Server/Utils/AI/RemediationCommandToolsRunnerScope.test.ts

@@ -111,6 +111,8 @@ function cluster(
       posture: posture || undefined,
     },
     accessMethod: "in_cluster",
+    aiAgent: null,
+    automaticInvestigation: { incidents: false, alerts: false },
     kubectlAllowlist: [],
     isInvestigationEnabled: true,
     isInvestigationReady: true,
@@ -233,7 +235,7 @@ describe("RemediationCommandToolkit.getRunnerScopeRefusal — the Runner's repor
     expect(
       refusalFor("kubectl rollout restart deployment/pay -n payments"),
     ).toContain(
-      'It only lets OneUptime AI change "web", "api" (aiAccess.remediation.namespaces on the Kubernetes agent chart).',
+      'It only lets OneUptime AI change "web", "api" (aiAccess.remediation.namespaces on the Kubernetes agent chart; after upgrading to the Kubernetes AI agent, aiAgent.remediation.namespaces).',
     );
     expect(refusalFor("kubectl rollout restart deployment/web")).toContain(
       "Name the target namespace with -n <namespace>.",
@@ -1063,3 +1065,125 @@ describe("RemediationCommandToolkit tells the model the Runner's scope as the Ru
     }
   });
 });
+
+/*
+ * The Kubernetes AI agent as the cluster's access target (runner.kind
+ * "ai_agent", accessMethod "in_cluster"): the same rule as the in-cluster
+ * Runner — a write with no -n lands in the agent pod's own namespace — in
+ * the agent's words, naming the aiAgent.* chart values. The previous
+ * in-cluster Runner's refusals say how to move to the agent; a credential
+ * Runner's name its own environment.
+ */
+describe("RemediationCommandToolkit.getRunnerScopeRefusal — who sets the scope, three ways", () => {
+  const AGENT_POSTURE: KubernetesRunnerPosture = {
+    inCluster: true,
+    allowWrites: true,
+    clusterIdentifier: "prod-us",
+    writeNamespaces: ["web", "api"],
+    podNamespace: "oneuptime-agent",
+    allowNodeOperations: false,
+  };
+
+  function agentCluster(): KubernetesClusterAiAccessStatus {
+    return cluster(AGENT_POSTURE, {
+      runner: {
+        id: RUNNER_ID.toString(),
+        name: "Kubernetes AI agent",
+        kind: "ai_agent",
+        isOnline: true,
+        canRunAiCommands: true,
+        posture: AGENT_POSTURE,
+      },
+    });
+  }
+
+  it("names the agent and aiAgent.remediation.namespaces for a write outside its scope", () => {
+    const refusal: string | null = refusalFor(
+      "kubectl rollout restart deployment/pay -n payments",
+      agentCluster(),
+    );
+
+    expect(refusal).toContain(
+      'outside the namespaces the Kubernetes AI agent of cluster "prod-us" may change',
+    );
+    expect(refusal).toContain(
+      "(aiAgent.remediation.namespaces on the Kubernetes agent chart)",
+    );
+    expect(refusal).not.toContain("aiAccess");
+    expect(refusal).not.toContain("the Runner of cluster");
+  });
+
+  it("names aiAgent.remediation.nodeOperations for a node operation", () => {
+    const refusal: string | null = refusalFor(
+      "kubectl cordon n1",
+      agentCluster(),
+    );
+
+    expect(refusal).toContain(
+      "aiAgent.remediation.nodeOperations=false on the Kubernetes agent chart",
+    );
+    expect(refusal).not.toContain("aiAccess");
+  });
+
+  it("judges a write with no -n against the agent pod's own namespace, as the agent does", () => {
+    const refusal: string | null = refusalFor(
+      "kubectl rollout restart deployment/web",
+      agentCluster(),
+    );
+
+    expect(refusal).toContain(
+      'names no namespace, so kubectl would run it in "oneuptime-agent"',
+    );
+    expect(refusal).toContain("never changes its own namespace");
+  });
+
+  it("negative control: a write inside the agent's scope is not refused", () => {
+    expect(
+      refusalFor(
+        "kubectl rollout restart deployment/web -n web",
+        agentCluster(),
+      ),
+    ).toBeNull();
+  });
+
+  it("getRunnerScopeSettings: the agent, the previous in-cluster Runner and a credential Runner each name their own setting", () => {
+    expect(
+      RemediationCommandToolkit.getRunnerScopeSettings(agentCluster()),
+    ).toEqual({
+      namespaces:
+        "aiAgent.remediation.namespaces on the Kubernetes agent chart",
+      nodeOperations:
+        "aiAgent.remediation.nodeOperations=false on the Kubernetes agent chart",
+    });
+
+    const legacy: { namespaces: string; nodeOperations: string } =
+      RemediationCommandToolkit.getRunnerScopeSettings(cluster(AGENT_POSTURE));
+
+    expect(legacy.namespaces).toContain(
+      "aiAccess.remediation.namespaces on the Kubernetes agent chart",
+    );
+    expect(legacy.namespaces).toContain(
+      "after upgrading to the Kubernetes AI agent, aiAgent.remediation.namespaces",
+    );
+    expect(legacy.nodeOperations).toContain(
+      "after upgrading to the Kubernetes AI agent, aiAgent.remediation.nodeOperations",
+    );
+
+    expect(
+      RemediationCommandToolkit.getRunnerScopeSettings(credentialCluster()),
+    ).toEqual({
+      namespaces: "ONEUPTIME_KUBECTL_WRITE_NAMESPACES on the Runner's host",
+      nodeOperations:
+        "ONEUPTIME_KUBECTL_ALLOW_NODE_OPERATIONS on the Runner's host",
+    });
+  });
+
+  it("the agent is told apart by kind only: a posture alone reads as the previous in-cluster Runner", () => {
+    const withoutKind: KubernetesClusterAiAccessStatus = agentCluster();
+    delete withoutKind.runner!.kind;
+
+    expect(
+      RemediationCommandToolkit.getRunnerScopeSettings(withoutKind).namespaces,
+    ).toContain("aiAccess.remediation.namespaces");
+  });
+});