feat(watch): queue conditions — back below N, stalled, oldest-age SLA (TRI-12890)

- queue_depth_below: the depth reader inverted, threshold in the identity;
  the honesty fence generalizes — a stale reading at or under the quiet
  line is unavailable for every depth kind (fixes a latent hole where
  queue_depth_above could verify 'stayed below' off stale data)
- queue_stalled: the first stateful kind — the check receives the previous
  check's frozen facts through a generic seam; an unavailable tick freezes
  the streak, never resets it; K=3 ticks internal default
- queue_oldest_age: 'runs wait longer than N minutes' over the same live
  seam the queue page's Oldest wait uses; live-only — a stale age is
  unavailable in both directions
- the queue card offers all five conditions with one contextual field;
  on a queue past the shared warning threshold the recommendation switches
  to the age SLA (single-source constant, the page aliases it)
- recurrence handoff: canonical error URIs never carry the friendly prefix
  (full-URI citations are normalized like bare ids)

Author: kathiekiwi

.server-changes/dashboard-agent-watch-queue-conditions.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+A queue watch can now wait for three more things under **Customize**: the queue coming back below a number you pick, the queue stopping moving at all, and runs waiting longer than a limit you set. On a queue where runs are already waiting too long, the **Watch…** button opens on that wait instead of on "until it clears".

apps/webapp/app/components/dashboard-agent/WatchCard.tsx

@@ -36,8 +36,9 @@ import { AgentSpinner } from "~/components/primitives/Spinner";
 import { cn } from "~/utils/cn";
 import { ChatSystemBlock } from "./chat-layout";
 import {
-  variantOf,
+  variantsOf,
   watchDraftError,
+  withAgeMinutes,
   withCadence,
   withFollowUp,
   withThreshold,
@@ -60,6 +61,9 @@ const VARIANT_LABEL: Record<WatchKind, string> = {
   run_failed: "if it fails",
   backlog_drain: "when it drains",
   queue_depth_above: "if it grows",
+  queue_depth_below: "when it's back below",
+  queue_stalled: "if it stops moving",
+  queue_oldest_age: "if runs wait too long",
   error_recurrence: "if it recurs",
   health_recovery: "when it recovers",
 };
@@ -127,7 +131,7 @@ export function WatchCard({
 }) {
   const [expanded, setExpanded] = useState(defaultExpanded);
   const { spec } = draft;
-  const variant = variantOf(draft);
+  const variants = variantsOf(draft);
   // Local validation first: a draft the schema would refuse never reaches the
   // server, and the same sentence appears whether it was caught here or there.
   const localError = watchDraftError(draft);
@@ -180,28 +184,30 @@ export function WatchCard({
         <div className="flex flex-col gap-3 pt-2">
           {/* The condition variant (§3). Only rendered where a second question
               exists — the kinds with none must not show an empty picker. */}
-          {variant ? (
+          {variants.length > 1 ? (
             <Field label="Tell me">
-              <Choice
-                selected
-                onSelect={() => {
-                  /* already the current condition */
-                }}
-              >
-                {VARIANT_LABEL[spec.kind]}
-              </Choice>
-              <Choice selected={false} onSelect={() => onChange(withVariant(draft, variant))}>
-                {VARIANT_LABEL[variant]}
-              </Choice>
+              {variants.map((kind) => (
+                <Choice
+                  key={kind}
+                  selected={kind === spec.kind}
+                  onSelect={() => {
+                    if (kind !== spec.kind) onChange(withVariant(draft, kind));
+                  }}
+                >
+                  {VARIANT_LABEL[kind]}
+                </Choice>
+              ))}
             </Field>
           ) : (
             <Field label="Tell me">
               <span className="text-xs text-text-dimmed">{watchConditionLabel(spec)}</span>
             </Field>
           )}
 
-          {spec.kind === "queue_depth_above" ? (
-            <Field label="Above">
+          {/* ONE contextual parameter per condition, and only for the conditions
+              that have one. The stall count stays internal (§3). */}
+          {spec.kind === "queue_depth_above" || spec.kind === "queue_depth_below" ? (
+            <Field label={spec.kind === "queue_depth_above" ? "Above" : "Below"}>
               <Input
                 type="number"
                 min={0}
@@ -218,6 +224,23 @@ export function WatchCard({
             </Field>
           ) : null}
 
+          {spec.kind === "queue_oldest_age" ? (
+            <Field label="Waiting longer than">
+              <Input
+                type="number"
+                min={1}
+                variant="small"
+                className="w-28"
+                value={Number.isFinite(spec.thresholdMinutes) ? String(spec.thresholdMinutes) : ""}
+                onChange={(event) =>
+                  onChange(withAgeMinutes(draft, Number.parseInt(event.target.value, 10)))
+                }
+                aria-label="Wait limit in minutes"
+              />
+              <span className="text-xs text-text-dimmed">minutes</span>
+            </Field>
+          ) : null}
+
           <Field label="For">
             {WATCH_WINDOW_HOURS_OPTIONS.map((hours) => (
               <Choice

apps/webapp/app/components/dashboard-agent/wake-banner.test.ts

@@ -162,6 +162,123 @@ describe("wakePresentation", () => {
     );
   });
 
+  // The queue pack (TRI-12890). Every headline is fact first (§5.3), and the
+  // numbers come from the frozen observation — never a fresh read.
+  it("says a queue came back below its threshold, and when it never did", () => {
+    const below = {
+      id: "watch_below",
+      kind: "queue_depth_below",
+      identity: "queue_depth_below:email-sends:100",
+      note: "",
+    };
+    expect(
+      wakePresentation("fired", {
+        ...below,
+        resolution: "condition_met",
+        observedOutcome: { kind: "queue_depth_below", verified: true, depth: 42, threshold: 100 },
+      })
+    ).toMatchObject({ headline: "email-sends queue is back below 100", category: "positive" });
+
+    expect(
+      wakePresentation("expired", {
+        ...below,
+        resolution: "window_completed",
+        observedOutcome: { kind: "queue_depth_below", verified: true, depth: 780, threshold: 100 },
+      })
+    ).toMatchObject({ headline: "email-sends queue is still above 100", category: "attention" });
+  });
+
+  it("says a queue is stuck at the depth it stalled on, and that it kept moving", () => {
+    const stalled = {
+      id: "watch_stalled",
+      kind: "queue_stalled",
+      identity: "queue_stalled:email-sends",
+      note: "",
+    };
+    expect(
+      wakePresentation("fired", {
+        ...stalled,
+        resolution: "condition_met",
+        observedOutcome: {
+          kind: "queue_stalled",
+          verified: true,
+          depth: 42,
+          notDecreasingStreak: 3,
+          ticks: 3,
+        },
+      })
+    ).toMatchObject({ headline: "email-sends queue is stuck at 42", category: "attention" });
+
+    expect(
+      wakePresentation("expired", {
+        ...stalled,
+        resolution: "window_completed",
+        observedOutcome: {
+          kind: "queue_stalled",
+          verified: true,
+          depth: 3,
+          notDecreasingStreak: 1,
+          ticks: 3,
+        },
+      })
+    ).toMatchObject({ headline: "email-sends queue kept moving", category: "positive" });
+  });
+
+  it("states the wait and the limit it passed, in minutes", () => {
+    const age = {
+      id: "watch_age",
+      kind: "queue_oldest_age",
+      identity: "queue_oldest_age:email-sends:5",
+      note: "",
+    };
+    expect(
+      wakePresentation("fired", {
+        ...age,
+        resolution: "condition_met",
+        observedOutcome: {
+          kind: "queue_oldest_age",
+          verified: true,
+          ageMs: 12 * 60_000,
+          thresholdMinutes: 5,
+        },
+      })
+    ).toMatchObject({
+      headline: "runs in email-sends are waiting 12m (over your 5m limit)",
+      category: "attention",
+    });
+
+    expect(
+      wakePresentation("expired", {
+        ...age,
+        resolution: "window_completed",
+        observedOutcome: {
+          kind: "queue_oldest_age",
+          verified: true,
+          ageMs: 30_000,
+          thresholdMinutes: 5,
+        },
+      })
+    ).toMatchObject({ headline: "email-sends queue stayed under 5m", category: "positive" });
+  });
+
+  it("names the queue, not the threshold, when a queue-pack watch's queue is gone", () => {
+    for (const [kind, identity] of [
+      ["queue_depth_below", "queue_depth_below:email-sends:100"],
+      ["queue_stalled", "queue_stalled:email-sends"],
+      ["queue_oldest_age", "queue_oldest_age:email-sends:5"],
+    ] as const) {
+      expect(
+        wakePresentation("expired", {
+          id: `watch_${kind}`,
+          kind,
+          identity,
+          note: "",
+          resolution: "condition_impossible",
+        })
+      ).toMatchObject({ headline: "email-sends queue no longer exists", category: "neutral" });
+    }
+  });
+
   it("recovers health without naming an identity", () => {
     expect(
       wakePresentation("fired", {