fix(billing): give the threshold toasts the cutover treatment

The threshold-crossing toasts were the one seat-era billing surface the
stack never touched: they fired on raw valve percentages regardless of
subscription state and spoke in "your monthly limit" language. The monitor
now emits thresholds only for confirmed free-tier orgs (a subscribed org's
valves are internal rails; unknown never reads as free), the copy says
"monthly/daily free usage", and the 100% path opens the modal with the
org_limit cause so it renders "Free usage used up".

Generated-By: PostHog Code
Task-Id: 1039ea23-9930-44e2-9888-b05cf8b129ec

Author: adboio

packages/core/src/usage/usage-monitor.test.ts

@@ -75,6 +75,7 @@ function makeUsage(overrides?: {
     user_id: 42,
     is_rate_limited: false,
     is_pro: overrides?.isPro ?? false,
+    code_usage_subscribed: false,
     billing_period_end:
       overrides?.billingPeriodEnd === undefined
         ? null
@@ -246,6 +247,32 @@ describe("UsageMonitorService", () => {
     expect(updates[1].burst.used_percent).toBe(35);
   });
 
+  it.each([
+    ["subscribed", true],
+    ["unknown", undefined],
+  ] as const)(
+    "does not emit thresholds for a %s org's internal valves",
+    async (_name, subscribed) => {
+      const usage = {
+        ...makeUsage({ sustainedPercent: 90 }),
+        code_usage_subscribed: subscribed,
+      };
+      service = makeService(mockGateway(usage), makeActivityMonitor());
+      const thresholds: unknown[] = [];
+      const updates: unknown[] = [];
+      service.on(UsageMonitorEvent.ThresholdCrossed, (e) =>
+        thresholds.push(e),
+      );
+      service.on(UsageMonitorEvent.UsageUpdated, (u) => updates.push(u));
+
+      await service.fetchOnce();
+
+      expect(thresholds).toHaveLength(0);
+      // The snapshot still flows to the meters.
+      expect(updates).toHaveLength(1);
+    },
+  );
+
   // The titlebar meter keys off this bit; a subscribe flip must not wait for
   // some other field to change.
   it("emits UsageUpdated when only the subscription bit flips", async () => {

packages/core/src/usage/usage-monitor.ts

@@ -1,6 +1,7 @@
 import { ROOT_LOGGER, type RootLogger } from "@posthog/di/logger";
 import { TypedEventEmitter } from "@posthog/shared";
 import { inject, injectable, postConstruct, preDestroy } from "inversify";
+import { isCodeUsageFreeTier } from "../billing/usageDisplay";
 import { USAGE_HOST, type UsageHost, type UsageLogger } from "./identifiers";
 import {
   USAGE_THRESHOLDS,
@@ -125,6 +126,9 @@ export class UsageMonitorService extends TypedEventEmitter<UsageMonitorEvents> {
   }
 
   private processUsage(usage: UsageOutput): void {
+    // Valve thresholds are a free-tier concept — a subscribed org's valves
+    // are internal rails, and unknown must never read as free.
+    if (!isCodeUsageFreeTier(usage)) return;
     const userId = usage.user_id.toString();
     const product = usage.product;
     this.maybeEmit(usage, "burst", usage.burst, userId, product, usage.is_pro);

packages/ui/src/features/billing/billing.contribution.ts

@@ -28,22 +28,25 @@ export class BillingContribution implements Contribution {
       onData: (event) => {
         const resetLabel = formatResetTime(event.resetAt);
 
+        // The monitor only emits thresholds for confirmed free-tier orgs, so
+        // the free-usage framing (and the org_limit cause) is always right.
         if (event.threshold === 100) {
           if (event.userIsActive) {
-            useUsageLimitStore.getState().show({ resetAt: event.resetAt });
+            useUsageLimitStore
+              .getState()
+              .show({ resetAt: event.resetAt, cause: "org_limit" });
             return;
           }
-          toast.error("Usage limit reached", {
+          toast.error("Free usage used up", {
             id: `usage-threshold-${event.bucket}-100`,
             description: resetLabel,
           });
           return;
         }
 
-        const limitName =
-          event.bucket === "burst" ? "daily limit" : "monthly limit";
+        const period = event.bucket === "burst" ? "daily" : "monthly";
         toast.warning(
-          `You've used ${Math.round(event.usedPercent)}% of your ${limitName}`,
+          `You've used ${Math.round(event.usedPercent)}% of your ${period} free usage`,
           {
             id: `usage-threshold-${event.bucket}-${event.threshold}`,
             description: resetLabel,