fix(webapp): limit rows only warn at their total bound, paused banner hides on the Concurrency page

A limit row's running count spans every concurrency key, so comparing it
against the perKey cap tripped the at-limit warning on healthy limits;
the warning and health badge now compare against the total bound and stay
quiet for perKey-only limits. The paused-environment banner's Manage
button hides again on the page it links to, which is /concurrency now.

Author: matt-aitken

apps/webapp/app/components/billing/OrgBanner.tsx

@@ -54,7 +54,7 @@ export function OrgBanner() {
     showSelfServe,
   });
 
-  const hideQueuesButton = location.pathname.endsWith("/queues");
+  const hideConcurrencyButton = location.pathname.endsWith("/concurrency");
   const hideBillingLimitBanner = location.pathname.endsWith("/settings/billing-limits");
 
   switch (bannerKind) {
@@ -70,7 +70,7 @@ export function OrgBanner() {
       return isArchived ? (
         <ArchivedEnvironmentBanner />
       ) : (
-        <PausedEnvironmentBanner hideButton={hideQueuesButton} />
+        <PausedEnvironmentBanner hideButton={hideConcurrencyButton} />
       );
     default:
       return null;

apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.concurrency/route.tsx

@@ -773,13 +773,22 @@ function QueuesWithMetricsView() {
               {queueRows.length > 0 ? (
                 queueRows.map((queue) => {
                   const limit = queue.concurrencyLimit ?? environment.concurrencyLimit;
-                  const isAtConcurrencyLimit = queue.running >= limit;
+                  const isLimit = queue.kind === "limit";
+                  /** A limit row's `running` counts holders across every key, so only its
+                   * total bound compares against it; a perKey-only limit has no aggregate
+                   * threshold and never reads as at-limit here. */
+                  const atLimitThreshold = isLimit
+                    ? queue.concurrency?.combined?.current != null
+                      ? Math.min(queue.concurrency.combined.current, environment.concurrencyLimit)
+                      : null
+                    : limit;
+                  const isAtConcurrencyLimit =
+                    atLimitThreshold !== null && queue.running >= atLimitThreshold;
                   const isAtQueueLimit =
                     environment.queueSizeLimit !== null &&
                     queue.queued >= environment.queueSizeLimit;
                   const queueFilterableName = queueMetricsKey(queue);
                   const queueMetric = metricsByQueue[queueFilterableName];
-                  const isLimit = queue.kind === "limit";
                   /** The detail page is queue observability (queue metrics, run filters, pause
                    * and override actions); a limit's activity lives on each holder's home queue,
                    * so limit rows don't link anywhere. */
@@ -1014,7 +1023,7 @@ function QueuesWithMetricsView() {
                           paused={queue.paused}
                           running={queue.running}
                           queued={queue.queued}
-                          limit={limit}
+                          limit={atLimitThreshold ?? 0}
                         />
                       </TableCell>
                       <TableCell
@@ -1952,11 +1961,20 @@ function ClassicQueuesView() {
                 {queues.length > 0 ? (
                   queues.map((queue) => {
                     const limit = queue.concurrencyLimit ?? environment.concurrencyLimit;
-                    const isAtConcurrencyLimit = queue.running >= limit;
+                    const isLimit = queue.kind === "limit";
+                    /** A limit row's `running` counts holders across every key, so only its
+                     * total bound compares against it; a perKey-only limit has no aggregate
+                     * threshold and never reads as at-limit here. */
+                    const atLimitThreshold = isLimit
+                      ? queue.concurrency?.combined?.current != null
+                        ? Math.min(queue.concurrency.combined.current, environment.concurrencyLimit)
+                        : null
+                      : limit;
+                    const isAtConcurrencyLimit =
+                      atLimitThreshold !== null && queue.running >= atLimitThreshold;
                     const isAtQueueLimit =
                       environment.queueSizeLimit !== null &&
                       queue.queued >= environment.queueSizeLimit;
-                    const isLimit = queue.kind === "limit";
                     const queueFilterableName = `${queue.type === "task" ? "task/" : ""}${
                       queue.name
                     }`;