@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+Query alerts now accept queries whose columns are computed from other aggregate columns, such as a percentage of two aggregates. When a query can't be watched, the Watch button stays visible but disabled and explains why.
@@ -100,13 +100,45 @@ describe("WatchQueryButton", () => {
     expect(container.textContent).toBe("");
   });
 
-  it("renders nothing when the analysis is ok but has no modes", () => {
+  it("disables the button and shows the first reason when the query can't be watched", () => {
+    const reason = "Remove time buckets from GROUP BY.";
     render({
       alertsPath: "/alerts",
       period: "7d",
-      watch: { query: "SELECT 1", analysis: analysis({}) },
+      watch: {
+        query: "SELECT 1",
+        analysis: analysis({
+          ok: false,
+          unsupported: [
+            { mode: "threshold", code: "group_by_time", message: reason },
+            { mode: "absence", code: "group_by_time", message: reason },
+            { mode: "match", code: "aggregated", message: "Other reason." },
+          ],
+        }),
+      },
     });
-    expect(container.textContent).toBe("");
+    const button = container.querySelector<HTMLButtonElement>("[data-testid=watch-query] button")!;
+    expect(button.textContent).toBe("Watch");
+    expect(button.getAttribute("aria-disabled")).toBe("true");
+    expect(button.tabIndex).toBe(0);
+    expect(container.querySelector("a")).toBeNull();
+    const describedBy = button.getAttribute("aria-describedby")!;
+    expect(document.getElementById(describedBy)!.textContent).toBe(reason);
+    expect(document.querySelector("[role=tooltip]")).toBeNull();
+    act(() => button.focus());
+    expect(document.querySelector("[role=tooltip]")!.textContent).toBe(reason);
+  });
+
+  it("enables the button for a supported query", () => {
+    render({
+      alertsPath: "/alerts",
+      period: "7d",
+      watch: { query: "SELECT count() AS failures FROM runs", analysis: THRESHOLD },
+    });
+    expect(
+      container.querySelector<HTMLAnchorElement>("[data-testid=watch-query] a")
+    ).not.toBeNull();
+    expect(container.querySelector("button")).toBeNull();
   });
 
   it("links to the alerts page with the query as base64url (catches dropped encoding)", () => {
@@ -168,11 +200,12 @@ describe("WatchQueryButton", () => {
     form.remove();
   });
 
-  it("renders nothing when the encoded query exceeds 8 KB even though it has fewer characters", () => {
+  it("disables the button when the encoded query exceeds 8 KB even though it has fewer characters", () => {
     const query = `SELECT count() AS failures FROM runs -- ${"é".repeat(3500)}`;
     expect(query.length).toBeLessThan(8192);
     render({ alertsPath: "/alerts", period: "1h", watch: { query, analysis: THRESHOLD } });
-    expect(container.textContent).toBe("");
+    expect(container.querySelector("button")!.getAttribute("aria-disabled")).toBe("true");
+    expect(container.querySelector("a")).toBeNull();
   });
 
   it("renders nothing when the analysis failed", () => {
 
@@ -1,10 +1,11 @@
 import { BellAlertIcon } from "@heroicons/react/20/solid";
-import { Button, LinkButton } from "~/components/primitives/Buttons";
+import { Button, ButtonContent, LinkButton } from "~/components/primitives/Buttons";
 import {
   watchBlockedReasons,
   watchQueryChoice,
   watchQueryHref,
 } from "~/components/alerts/queryAlertLink";
+import { SimpleTooltip } from "~/components/primitives/Tooltip";
 import { useDashboardAgent } from "~/components/dashboard-agent/dashboardAgentLauncher";
 import type { QueryAlertAnalysis } from "~/v3/services/alerts/queryAlerts/analyzeQueryForAlert.server";
 
@@ -21,8 +22,38 @@ export function WatchQueryButton({
 }) {
   const agent = useDashboardAgent();
   const analysis = watch?.analysis;
-  if (!watch || !analysis?.ok || watchBlockedReasons(analysis, watch.query).length > 0) {
-    return null;
+  if (!watch || !analysis) return null;
+  const [reason] = watchBlockedReasons(analysis, watch.query);
+  if (reason) {
+    return (
+      <span data-testid="watch-query">
+        <SimpleTooltip
+          asChild
+          tabbable
+          button={
+            <button
+              type="button"
+              aria-disabled="true"
+              aria-describedby="watch-query-reason"
+              className="group/button cursor-default opacity-60 outline-hidden focus-custom"
+              onClick={(e) => e.preventDefault()}
+            >
+              <ButtonContent
+                variant="secondary/small"
+                LeadingIcon={BellAlertIcon}
+                leadingIconClassName="text-alerts"
+              >
+                Watch
+              </ButtonContent>
+            </button>
+          }
+          content={reason}
+        />
+        <span id="watch-query-reason" className="sr-only">
+          {reason}
+        </span>
+      </span>
+    );
   }
   return (
     <span data-testid="watch-query">
 
@@ -1,10 +1,13 @@
+import { getQuerySource } from "@internal/alert-contracts";
 import type { QueryAlertAnalysis } from "~/v3/services/alerts/queryAlerts/analyzeQueryForAlert.server";
 import { parsePeriodToMs } from "~/utils/periods";
 
 export const MAX_WATCH_QUERY_LENGTH = 8192;
 const MAX_DEFAULT_WINDOW_MINUTES = 24 * 60;
 export const UNUSABLE_QUERY = "This query can't be used for an alert.";
 
+const MODE_MISMATCH_CODES = new Set(["aggregated", "rows_need_aggregate"]);
+
 export type QueryAlertMode = "threshold" | "absence" | "match";
 
 export type QueryAlertPrefill = {
@@ -43,7 +46,15 @@ export function watchBlockedReasons(analysis: QueryAlertAnalysis, query: string)
   if (encodeQueryParam(query).length > MAX_WATCH_QUERY_LENGTH)
     return ["Query is too long to watch"];
   if (analysis.ok && analysis.modes.length > 0) return [];
-  const messages = [...analysis.errors, ...analysis.unsupported].map((issue) => issue.message);
+  const matchable = analysis.sources.some((s) =>
+    getQuerySource(s.sourceId)?.modes.includes("match")
+  );
+  const issues = [
+    ...analysis.errors,
+    ...analysis.unsupported.filter((issue) => matchable || issue.mode !== "match"),
+  ];
+  const specific = issues.filter((issue) => !MODE_MISMATCH_CODES.has(issue.code));
+  const messages = (specific.length ? specific : issues).map((issue) => issue.message);
   const unique = [...new Set(messages)].slice(0, 2);
   return unique.length ? unique : [UNUSABLE_QUERY];
 }
 
@@ -389,13 +389,32 @@ export function ButtonContent(props: ButtonContentPropsType) {
 
 type ButtonPropsType = Pick<
   JSX.IntrinsicElements["button"],
-  "type" | "disabled" | "onClick" | "name" | "value" | "form" | "autoFocus" | "aria-label"
+  | "type"
+  | "disabled"
+  | "onClick"
+  | "name"
+  | "value"
+  | "form"
+  | "autoFocus"
+  | "aria-label"
+  | "aria-describedby"
 > &
   React.ComponentProps<typeof ButtonContent>;
 
 /* oxlint-disable react/button-has-type -- Callers can select button, reset, or submit semantics. */
 export const Button = forwardRef<HTMLButtonElement, ButtonPropsType>(
-  ({ type, disabled, autoFocus, onClick, "aria-label": ariaLabel, ...props }, ref) => {
+  (
+    {
+      type,
+      disabled,
+      autoFocus,
+      onClick,
+      "aria-label": ariaLabel,
+      "aria-describedby": ariaDescribedBy,
+      ...props
+    },
+    ref
+  ) => {
     const innerRef = useRef<HTMLButtonElement>(null);
     useImperativeHandle(ref, () => innerRef.current as HTMLButtonElement);
 
@@ -425,6 +444,7 @@ export const Button = forwardRef<HTMLButtonElement, ButtonPropsType>(
         form={props.form}
         autoFocus={autoFocus}
         aria-label={ariaLabel}
+        aria-describedby={ariaDescribedBy}
       >
         <ButtonContent
           {...props}
 
@@ -11,8 +11,10 @@ import {
   ExposedTSQLError,
   measureTSQLNesting,
   parseTSQLSelect,
+  type Alias,
   type Call,
   type Expression,
+  type Field,
   type OutputColumnMetadata,
   type SelectQuery,
   type TableSchema,
@@ -26,8 +28,10 @@ import {
   branchesOf,
   containsAggregate,
   containsWindowFunction,
+  fieldsIn,
   fromEntries,
   hasFreeField,
+  isStar,
   isField,
   itemName,
   lastName,
@@ -465,7 +469,30 @@ function analyzeShape(
 
   const query = branches[0]!;
   const items = query.select;
-  const aggregateItem = items.map((item) => containsAggregate(item) && !hasFreeField(item));
+  const visible = visibleColumns(query, schemas, tables);
+  const aliases = items.flatMap((item) =>
+    item.expression_type === "alias" ? [(item as Alias).alias.toLowerCase()] : []
+  );
+  const ambiguous = new Set(aliases.filter((a, i) => aliases.indexOf(a) !== i));
+  const aggregateAliases = new Set<string>();
+  const isAggregateRef = (f: Field) => {
+    const name = String(f.chain[0]);
+    return f.chain.length === 1 && !visible.has(name) && aggregateAliases.has(name.toLowerCase());
+  };
+  const isAggregateItem = (item: Expression) =>
+    (containsAggregate(item) || fieldsIn(item).some(isAggregateRef)) &&
+    !hasFreeField(item, isAggregateRef);
+  for (let grew = true; grew;) {
+    grew = false;
+    for (const item of items) {
+      const alias = item.expression_type === "alias" ? (item as Alias).alias.toLowerCase() : "";
+      if (alias && !ambiguous.has(alias) && !aggregateAliases.has(alias) && isAggregateItem(item)) {
+        aggregateAliases.add(alias);
+        grew = true;
+      }
+    }
+  }
+  const aggregateItem = items.map(isAggregateItem);
   const grouped = !!query.group_by?.length;
 
   if (!grouped && aggregateItem.some((a) => !a)) {
@@ -529,6 +556,22 @@ function analyzeShape(
   };
 }
 
+function visibleColumns(
+  query: SelectQuery,
+  schemas: Map<string, TableSchema>,
+  tables: string[]
+): Set<string> {
+  const columnsOf = (table: string) => Object.keys(schemas.get(table)?.columns ?? {});
+  return new Set(
+    fromEntries(query).flatMap((entry) => {
+      if (entry.kind === "table") return columnsOf(entry.table);
+      const select = branchesOf(entry.query)[0]?.select ?? [];
+      if (select.some(isStar)) return tables.flatMap(columnsOf);
+      return select.flatMap((item) => itemName(item) ?? []);
+    })
+  );
+}
+
 function groupsByTime(
   query: SelectQuery,
   schemas: Map<string, TableSchema>,