@aliou/pi-neuralwatt 0.7.6 → 0.8.1

package/README.md

@@ -36,7 +36,7 @@ pi install npm:@aliou/pi-neuralwatt
 pi install git:github.com/aliou/pi-neuralwatt
 
 # Local development
-pi -e ./src/extensions/provider/index.ts
+pi -e ./extensions/provider/index.ts
 ```
 
 ## Usage
@@ -80,9 +80,11 @@ Configure features with `/neuralwatt:settings`:
 
 The provider itself cannot be disabled — it is always loaded.
 
+Configuration uses nested per-feature sections. Existing flat config files are migrated automatically, with a backup written next to the migrated config.
+
 ## Adding or Updating Models
 
-Models are hardcoded in `src/extensions/provider/models.ts` and validated against the live API. To update:
+Models are hardcoded in `extensions/provider/models/public-models.ts` and validated against the live API. To update:
 
 1. Run `pnpm test` — it fetches `/v1/models` and compares against hardcoded definitions
 2. Fix any discrepancies (missing models, changed context windows)

package/{src/extensions → extensions}/command-quotas/command.ts

@@ -3,8 +3,8 @@ import {
   type ExtensionAPI,
   getAgentDir,
 } from "@earendil-works/pi-coding-agent";
-import { getNeuralwattApiKey } from "../../lib/env";
-import { fetchQuotas } from "../../lib/neuralwatt-api";
+import { fetchQuotas } from "../../src/lib/neuralwatt-api";
+import { getNeuralwattApiKey } from "../_shared/auth";
 import { QuotasComponent } from "./components/quotas-display";
 
 function missingAuthMessage(): string {

package/extensions/command-quotas/components/progress-bar.ts

@@ -0,0 +1,38 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Severity } from "../../../src/utils/quota-bar";
+
+export type BarStyle = "filled-used" | "filled-remaining";
+
+/**
+ * Render a progress bar.
+ *
+ * filled-used: filled region = used portion (colored by severity of remaining%)
+ * filled-remaining: filled region = remaining portion (colored by severity of remaining%)
+ */
+export function renderProgressBar(
+  percent: number,
+  width: number,
+  theme: Theme,
+  severity: Severity,
+  style: BarStyle = "filled-remaining",
+): string {
+  const clamped = Math.max(0, Math.min(100, Math.round(percent)));
+  const filledCount = Math.round((clamped / 100) * width);
+
+  const parts: string[] = [];
+  for (let idx = 0; idx < width; idx++) {
+    const isFilled = idx < filledCount;
+    if (style === "filled-used") {
+      // filled = used (severity color), empty = remaining (dim)
+      parts.push(
+        isFilled ? theme.fg(severity, "\u2593") : theme.fg("success", "\u2591"),
+      );
+    } else {
+      // filled = remaining (severity color), empty = used (dim)
+      parts.push(
+        isFilled ? theme.fg(severity, "\u2588") : theme.fg("dim", "\u2591"),
+      );
+    }
+  }
+  return parts.join("");
+}

package/{src/extensions → extensions}/command-quotas/components/quota-tabs.ts

@@ -1,17 +1,17 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import type { NeuralwattQuotas } from "../../../types/quota-api";
+import type { NeuralwattQuotas } from "../../../src/types/quota-api";
 import {
   percentCreditsRemaining,
   percentEnergyRemaining,
-  renderProgressBar,
   severityFromPercent,
-} from "../../../utils/quota-bar";
+} from "../../../src/utils/quota-bar";
 import {
   formatKwh,
   formatTokens,
   formatUsd,
-} from "../../../utils/quota-format";
+} from "../../../src/utils/quota-format";
+import { renderProgressBar } from "./progress-bar";
 
 /**
  * Subscription tab — plan details, energy quota, billing period.

package/{src/extensions → extensions}/command-quotas/components/quotas-display.ts

@@ -2,7 +2,7 @@ import type { Theme } from "@earendil-works/pi-coding-agent";
 import { DynamicBorder } from "@earendil-works/pi-coding-agent";
 import type { Component, TUI } from "@earendil-works/pi-tui";
 import { Loader, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
-import type { NeuralwattQuotas } from "../../../types/quota-api";
+import type { NeuralwattQuotas } from "../../../src/types/quota-api";
 import {
   renderCreditsTab,
   renderSubscriptionTab,

package/{src/extensions → extensions}/command-quotas/index.ts

@@ -1,9 +1,9 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { configLoader } from "../../src/config";
 import {
-  configLoader,
   NEURALWATT_EXTENSIONS_REGISTER_EVENT,
   NEURALWATT_EXTENSIONS_REQUEST_EVENT,
-} from "../../config";
+} from "../../src/events";
 import { registerQuotasCommand } from "./command";
 
 export default async function (pi: ExtensionAPI) {
@@ -11,7 +11,7 @@ export default async function (pi: ExtensionAPI) {
 
   const config = configLoader.getConfig();
 
-  if (config.quotaCommand) {
+  if (config.quotaCommand.enabled) {
     registerQuotasCommand(pi);
   }
 

package/extensions/provider/commands/settings/index.ts

@@ -0,0 +1,246 @@
+import {
+  registerSettingsCommand,
+  type SettingsSection,
+} from "@aliou/pi-utils-settings";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { SettingItem } from "@earendil-works/pi-tui";
+import {
+  configLoader,
+  type NeuralwattConfig,
+  type NeuralwattRawConfig,
+  type ResolvedNeuralwattConfig,
+} from "../../../../src/config";
+import {
+  NEURALWATT_CONFIG_UPDATED_EVENT,
+  type NeuralwattFeatureId,
+} from "../../../../src/events";
+
+export interface RegisterNeuralwattSettingsOptions {
+  getLoadedFeatures: () => Set<NeuralwattFeatureId>;
+}
+
+function emitConfigUpdated(pi: ExtensionAPI): void {
+  pi.events.emit(NEURALWATT_CONFIG_UPDATED_EVENT, {
+    config: configLoader.getConfig(),
+  });
+}
+
+function featureRow(
+  id: NeuralwattFeatureId,
+  label: string,
+  description: string,
+  configValue: boolean,
+  isLoaded: boolean,
+): SettingItem {
+  if (isLoaded) {
+    return {
+      id,
+      label,
+      description,
+      currentValue: configValue ? "enabled" : "disabled",
+      values: ["enabled", "disabled"],
+    };
+  }
+  return {
+    id,
+    label,
+    description: `${description} (Not loaded by Pi)`,
+    currentValue: "unavailable",
+    values: [],
+  };
+}
+
+function optionalFeatureValue(value: unknown): boolean | undefined {
+  if (typeof value === "boolean") return value;
+  if (value && typeof value === "object") {
+    const enabled = (value as { enabled?: boolean }).enabled;
+    if (typeof enabled === "boolean") return enabled;
+  }
+  return undefined;
+}
+
+function featureValue(value: unknown, fallback: boolean): boolean {
+  return optionalFeatureValue(value) ?? fallback;
+}
+
+function toNestedConfig(config: NeuralwattRawConfig): NeuralwattConfig {
+  const provider = "provider" in config ? config.provider : undefined;
+
+  return {
+    provider: {
+      ...(provider ?? {}),
+      includeLegacyModelIds:
+        provider?.includeLegacyModelIds ??
+        ("includeLegacyModelIds" in config
+          ? config.includeLegacyModelIds
+          : undefined),
+      includeHiddenModels:
+        provider?.includeHiddenModels ??
+        ("includeHiddenModels" in config
+          ? config.includeHiddenModels
+          : undefined),
+    },
+    quotaCommand: {
+      ...(typeof config.quotaCommand === "object" ? config.quotaCommand : {}),
+      enabled: optionalFeatureValue(config.quotaCommand),
+    },
+    quotaWarnings: {
+      ...(typeof config.quotaWarnings === "object" ? config.quotaWarnings : {}),
+      enabled: optionalFeatureValue(config.quotaWarnings),
+    },
+    subBarIntegration: {
+      ...(typeof config.subBarIntegration === "object"
+        ? config.subBarIntegration
+        : {}),
+      enabled: optionalFeatureValue(config.subBarIntegration),
+    },
+  };
+}
+
+export function registerNeuralwattSettings(
+  pi: ExtensionAPI,
+  options: RegisterNeuralwattSettingsOptions,
+): void {
+  const { getLoadedFeatures } = options;
+
+  registerSettingsCommand<NeuralwattRawConfig, ResolvedNeuralwattConfig>(pi, {
+    commandName: "neuralwatt:settings",
+    title: "Neuralwatt Settings",
+    configStore: configLoader,
+    buildSections: (tabConfig, resolved): SettingsSection[] => {
+      const loaded = getLoadedFeatures();
+      return [
+        {
+          label: "Features",
+          items: [
+            featureRow(
+              "quotaCommand",
+              "Quota command",
+              "Toggle the /neuralwatt:quota command, showing your API usage at a glance",
+              featureValue(
+                tabConfig?.quotaCommand,
+                resolved.quotaCommand.enabled,
+              ),
+              loaded.has("quotaCommand"),
+            ),
+            featureRow(
+              "quotaWarnings",
+              "Quota warnings",
+              "Toggle notifications when credits or energy are running low",
+              featureValue(
+                tabConfig?.quotaWarnings,
+                resolved.quotaWarnings.enabled,
+              ),
+              loaded.has("quotaWarnings"),
+            ),
+            featureRow(
+              "subBarIntegration",
+              "Sub-bar integration",
+              "Toggle integration with the status bar and sub-core",
+              featureValue(
+                tabConfig?.subBarIntegration,
+                resolved.subBarIntegration.enabled,
+              ),
+              loaded.has("subBarIntegration"),
+            ),
+          ],
+        },
+        {
+          label: "Other settings",
+          items: [
+            {
+              id: "includeLegacyModelIds",
+              label: "Legacy model IDs",
+              description:
+                "Include deprecated Neuralwatt model IDs as aliases in the model picker",
+              currentValue:
+                ((tabConfig &&
+                  "provider" in tabConfig &&
+                  tabConfig.provider?.includeLegacyModelIds) ??
+                (tabConfig &&
+                  "includeLegacyModelIds" in tabConfig &&
+                  tabConfig.includeLegacyModelIds) ??
+                resolved.provider.includeLegacyModelIds)
+                  ? "include"
+                  : "ignore",
+              values: ["include", "ignore"],
+            },
+            {
+              id: "includeHiddenModels",
+              label: "Hidden models",
+              description:
+                "Include Neuralwatt models that are accessible via API key but not advertised in the public model list",
+              currentValue:
+                ((tabConfig &&
+                  "provider" in tabConfig &&
+                  tabConfig.provider?.includeHiddenModels) ??
+                (tabConfig &&
+                  "includeHiddenModels" in tabConfig &&
+                  tabConfig.includeHiddenModels) ??
+                resolved.provider.includeHiddenModels)
+                  ? "include"
+                  : "ignore",
+              values: ["include", "ignore"],
+            },
+          ],
+        },
+      ];
+    },
+    onSettingChange: (id, newValue, config) => {
+      // Non-feature toggles are handled first so they are not blocked by the
+      // loaded-features guard (they are managed directly by the provider).
+      if (id === "includeLegacyModelIds") {
+        const nestedConfig = toNestedConfig(config);
+        return {
+          ...nestedConfig,
+          provider: {
+            ...nestedConfig.provider,
+            includeLegacyModelIds: newValue === "include",
+          },
+        };
+      }
+
+      if (id === "includeHiddenModels") {
+        const nestedConfig = toNestedConfig(config);
+        return {
+          ...nestedConfig,
+          provider: {
+            ...nestedConfig.provider,
+            includeHiddenModels: newValue === "include",
+          },
+        };
+      }
+
+      if (!getLoadedFeatures().has(id as NeuralwattFeatureId)) {
+        return null;
+      }
+
+      const enabled = newValue === "enabled";
+      switch (id) {
+        case "quotaCommand":
+          return {
+            ...toNestedConfig(config),
+            quotaCommand: { ...toNestedConfig(config).quotaCommand, enabled },
+          };
+        case "quotaWarnings":
+          return {
+            ...toNestedConfig(config),
+            quotaWarnings: { ...toNestedConfig(config).quotaWarnings, enabled },
+          };
+        case "subBarIntegration":
+          return {
+            ...toNestedConfig(config),
+            subBarIntegration: {
+              ...toNestedConfig(config).subBarIntegration,
+              enabled,
+            },
+          };
+        default:
+          return null;
+      }
+    },
+    onSave: async () => {
+      emitConfigUpdated(pi);
+    },
+  });
+}

package/{src/extensions → extensions}/provider/index.ts

@@ -1,25 +1,22 @@
-import { getApiProvider } from "@earendil-works/pi-ai";
+import { getApiProvider } from "@earendil-works/pi-ai/compat";
 import type {
   ExtensionAPI,
   ProviderModelConfig,
 } from "@earendil-works/pi-coding-agent";
+import { configLoader } from "../../src/config";
 import {
-  configLoader,
-  emitConfigUpdated,
   NEURALWATT_CONFIG_UPDATED_EVENT,
   NEURALWATT_EXTENSIONS_REGISTER_EVENT,
   NEURALWATT_EXTENSIONS_REQUEST_EVENT,
-  type NeuralwattFeatureId,
-  registerNeuralwattSettings,
-} from "../../config";
-import { getNeuralwattApiKey } from "../../lib/env";
-import { fetchQuotas } from "../../lib/neuralwatt-api";
-import type { NeuralwattQuotas } from "../../types/quota-api";
-import {
   NEURALWATT_QUOTAS_REQUEST_EVENT,
   NEURALWATT_QUOTAS_UPDATED_EVENT,
+  type NeuralwattFeatureId,
   type NeuralwattQuotasUpdatedPayload,
-} from "../../types/quota-events";
+} from "../../src/events";
+import { fetchQuotas } from "../../src/lib/neuralwatt-api";
+import type { NeuralwattQuotas } from "../../src/types/quota-api";
+import { getNeuralwattApiKey } from "../_shared/auth";
+import { registerNeuralwattSettings } from "./commands/settings";
 import { normalizeNeuralwattContextOverflowError } from "./context-overflow";
 import {
   getNeuralwattModels,
@@ -38,16 +35,23 @@ import { wrapNeuralwattStreamSimple } from "./stream-simple";
 
 const HEADER_EMIT_THROTTLE_MS = 5_000;
 
+function emitConfigUpdated(pi: ExtensionAPI): void {
+  pi.events.emit(NEURALWATT_CONFIG_UPDATED_EVENT, {
+    config: configLoader.getConfig(),
+  });
+}
+
 function registerNeuralwattProvider(
   pi: ExtensionAPI,
   onSseQuota: (line: string) => void,
   hiddenModels: ProviderModelConfig[] = [],
 ): void {
-  const { includeLegacyModelIds, includeHiddenModels } =
-    configLoader.getConfig();
+  const { provider: providerConfig } = configLoader.getConfig();
 
-  const publicModels = getNeuralwattModels({ includeLegacyModelIds });
-  const resolvedHiddenModels = includeHiddenModels
+  const publicModels = getNeuralwattModels({
+    includeLegacyModelIds: providerConfig.includeLegacyModelIds,
+  });
+  const resolvedHiddenModels = providerConfig.includeHiddenModels
     ? dedupeHiddenModels(hiddenModels, publicModels)
     : [];
 
@@ -109,20 +113,23 @@ export default async function (pi: ExtensionAPI) {
   // load time. `session_start` then revalidates from the live API and writes
   // the cache back. First run with no cache still warns once.
   let hiddenModels: ProviderModelConfig[] = [];
-  if (configLoader.getConfig().includeHiddenModels) {
+  if (configLoader.getConfig().provider.includeHiddenModels) {
     hiddenModels = loadCachedHiddenModels();
   }
   let hiddenModelsLoaded = false;
   let hiddenModelsAbort: AbortController | undefined;
 
+  let lastSseEmitAt = 0;
+
   const handleSseQuota = (line: string) => {
+    const now = Date.now();
+    if (now - lastSseEmitAt < HEADER_EMIT_THROTTLE_MS) return;
+
     const quotas = updateQuotasFromSseComment(latestQuotas, line);
     if (!quotas || quotas === latestQuotas) return;
-    latestQuotas = quotas;
-    pi.events.emit(NEURALWATT_QUOTAS_UPDATED_EVENT, {
-      quotas,
-      source: "sse",
-    });
+
+    lastSseEmitAt = now;
+    emitQuotas(quotas, "sse");
   };
 
   registerNeuralwattProvider(pi, handleSseQuota, hiddenModels);
@@ -139,7 +146,7 @@ export default async function (pi: ExtensionAPI) {
     // cache so previously discovered models are available immediately without
     // waiting for the next session_start revalidation.
     if (
-      configLoader.getConfig().includeHiddenModels &&
+      configLoader.getConfig().provider.includeHiddenModels &&
       !hiddenModelsLoaded &&
       hiddenModels.length === 0
     ) {
@@ -257,15 +264,19 @@ export default async function (pi: ExtensionAPI) {
 
   pi.on("session_start", async (_event, ctx) => {
     pendingRateLimitInfo = undefined;
-    for (const message of configLoader.drainMessages()) {
-      ctx.ui.notify(message, "warning");
+    const messages = [...new Set(configLoader.drainMessages())];
+    if (messages.length > 0) {
+      ctx.ui.notify(messages.join("\n"), "info");
     }
 
     loadedFeatures.clear();
     pi.events.emit(NEURALWATT_EXTENSIONS_REQUEST_EVENT, undefined);
     emitConfigUpdated(pi);
 
-    if (!hiddenModelsLoaded && configLoader.getConfig().includeHiddenModels) {
+    if (
+      !hiddenModelsLoaded &&
+      configLoader.getConfig().provider.includeHiddenModels
+    ) {
       hiddenModelsLoaded = true;
       hiddenModelsAbort?.abort();
       hiddenModelsAbort = new AbortController();

package/{src/extensions → extensions}/provider/models/hidden.ts

@@ -2,9 +2,9 @@ import type {
   AuthStorage,
   ProviderModelConfig,
 } from "@earendil-works/pi-coding-agent";
-import { getNeuralwattApiKey } from "../../../lib/env";
-import { fetchNeuralwattModels } from "../../../lib/neuralwatt-api";
-import type { NeuralwattApiModel } from "../../../types/models-api";
+import { fetchNeuralwattModels } from "../../../src/lib/neuralwatt-api";
+import type { NeuralwattApiModel } from "../../../src/types/models-api";
+import { getNeuralwattApiKey } from "../../_shared/auth";
 import { NEURALWATT_MODELS } from "./public-models";
 
 // Per-ID overrides for known hidden models. The authenticated /v1/models endpoint

package/{src/extensions → extensions}/provider/quota-store.ts

@@ -1,8 +1,8 @@
 import type { AuthStorage } from "@earendil-works/pi-coding-agent";
-import { getNeuralwattApiKey } from "../../lib/env";
-import { fetchQuotas } from "../../lib/neuralwatt-api";
-import type { NeuralwattQuotas } from "../../types/quota-api";
-import { parseQuotaHeaders } from "../../types/quota-events";
+import { parseQuotaHeaders } from "../../src/events";
+import { fetchQuotas } from "../../src/lib/neuralwatt-api";
+import type { NeuralwattQuotas } from "../../src/types/quota-api";
+import { getNeuralwattApiKey } from "../_shared/auth";
 
 export function buildQuotasFromHeaders(
   headers: Record<string, string>,

package/{src/extensions → extensions}/provider/sse-quotas.ts

@@ -1,4 +1,4 @@
-import type { NeuralwattQuotas } from "../../types/quota-api";
+import type { NeuralwattQuotas } from "../../src/types/quota-api";
 
 const JOULES_PER_KWH = 3_600_000;
 

package/{src/extensions → extensions}/quota-warnings/index.ts

@@ -2,29 +2,27 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+import { configLoader } from "../../src/config";
 import {
-  configLoader,
   NEURALWATT_CONFIG_UPDATED_EVENT,
   NEURALWATT_EXTENSIONS_REGISTER_EVENT,
   NEURALWATT_EXTENSIONS_REQUEST_EVENT,
-  type NeuralwattConfigUpdatedPayload,
-} from "../../config";
-import {
   NEURALWATT_QUOTAS_UPDATED_EVENT,
+  type NeuralwattConfigUpdatedPayload,
   type NeuralwattQuotasUpdatedPayload,
-} from "../../types/quota-events";
+} from "../../src/events";
 import { checkQuotas, clearAlertState } from "./notifier";
 
 export default async function (pi: ExtensionAPI) {
   await configLoader.load();
 
-  let enabled = configLoader.getConfig().quotaWarnings;
-  let currentProvider: string | undefined;
+  let enabled = configLoader.getConfig().quotaWarnings.enabled;
   let currentContext: ExtensionContext | undefined;
 
   // Listen for config changes at runtime
   pi.events.on(NEURALWATT_CONFIG_UPDATED_EVENT, (data: unknown) => {
-    enabled = (data as NeuralwattConfigUpdatedPayload).config.quotaWarnings;
+    enabled = (data as NeuralwattConfigUpdatedPayload).config.quotaWarnings
+      .enabled;
 
     if (!enabled) {
       clearAlertState();
@@ -34,36 +32,29 @@ export default async function (pi: ExtensionAPI) {
   pi.events.on(NEURALWATT_QUOTAS_UPDATED_EVENT, (data: unknown) => {
     if (!enabled) return;
     if (!data || typeof data !== "object") return;
-    if (currentProvider !== "neuralwatt" || !currentContext) return;
-    const { quotas, source } = data as NeuralwattQuotasUpdatedPayload;
-    checkQuotas(currentContext, quotas, source === "header");
+    if (!currentContext) return;
+    if (currentContext.model?.provider !== "neuralwatt") return;
+
+    const { quotas } = data as NeuralwattQuotasUpdatedPayload;
+    checkQuotas(currentContext, quotas);
   });
 
   pi.on("session_start", async (_event, ctx) => {
     currentContext = ctx;
-    currentProvider = ctx.model?.provider;
     if (ctx.model?.provider !== "neuralwatt") return;
     clearAlertState();
   });
 
   pi.on("model_select", (_event, ctx) => {
     currentContext = ctx;
-    currentProvider = ctx.model?.provider;
-    if (ctx.model?.provider !== "neuralwatt") {
-      clearAlertState();
-      return;
-    }
-    clearAlertState();
   });
 
   pi.on("session_before_switch", (_event, ctx) => {
     currentContext = ctx;
-    currentProvider = ctx.model?.provider;
   });
 
   pi.on("session_shutdown", () => {
     currentContext = undefined;
-    currentProvider = undefined;
     clearAlertState();
   });
 

package/{src/extensions → extensions}/quota-warnings/notifier.ts

@@ -1,6 +1,6 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { NeuralwattQuotas } from "../../types/quota-api";
-import { formatKwh, formatUsd } from "../../utils/quota-format";
+import type { NeuralwattQuotas } from "../../src/types/quota-api";
+import { formatKwh, formatUsd } from "../../src/utils/quota-format";
 
 export type WarningSeverity = "warning" | "critical";
 
@@ -11,6 +11,8 @@ interface AlertState {
   lastNotifiedAt: number;
 }
 
+// Module-level state so cooldowns survive across invocations of checkQuotas()
+// within the same Pi runtime.
 const alerts = new Map<string, AlertState>();
 
 export function clearAlertState(): void {
@@ -22,9 +24,9 @@ function shouldNotify(key: string, severity: WarningSeverity): boolean {
   if (!state) return true;
 
   const order: WarningSeverity[] = ["warning", "critical"];
-  if (order.indexOf(severity) > order.indexOf(state.lastSeverity)) return true;
-
-  if (severity === "critical") return true;
+  const currentIndex = order.indexOf(severity);
+  const lastIndex = order.indexOf(state.lastSeverity);
+  if (currentIndex > lastIndex) return true;
 
   return Date.now() - state.lastNotifiedAt >= COOLDOWN_MS;
 }
@@ -40,7 +42,6 @@ function markNotified(key: string, severity: WarningSeverity): void {
 export function checkQuotas(
   ctx: ExtensionContext,
   quotas: NeuralwattQuotas,
-  skipAlreadyWarned: boolean,
 ): void {
   if (!ctx.hasUI) return;
 
@@ -55,7 +56,7 @@ export function checkQuotas(
       if (pct <= 25) {
         const severity: WarningSeverity = pct <= 10 ? "critical" : "warning";
         const key = "credits";
-        if (!skipAlreadyWarned || shouldNotify(key, severity)) {
+        if (shouldNotify(key, severity)) {
           markNotified(key, severity);
           warnings.push(
             `Credits: ${pct.toFixed(0)}% remaining (${formatUsd(credits_remaining_usd)} of ${formatUsd(total_credits_usd)})`,
@@ -77,7 +78,7 @@ export function checkQuotas(
             ? "critical"
             : "warning";
         const key = "energy";
-        if (!skipAlreadyWarned || shouldNotify(key, severity)) {
+        if (shouldNotify(key, severity)) {
           markNotified(key, severity);
           const tag = in_overage ? " [OVERAGE]" : "";
           warnings.push(