fix(webapp): queue watch recommendation must be a future condition; exit agent fullscreen on navigation

An already-late queue was recommended the age SLA — already true, so every
watch one-shot with "that already happened". Late queue now recommends the
drain (the recovery); a healthy queue recommends the age SLA.

Navigating to another page drops the fullscreen takeover back to the side
panel.

Author: kathiekiwi

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

@@ -1,4 +1,5 @@
 import type { SuggestedPrompt, WatchSpec } from "@internal/dashboard-agent-contracts";
+import { useLocation } from "@remix-run/react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   ResizableHandle,
@@ -73,6 +74,21 @@ export function DashboardAgent({
       return !current;
     });
   }, []);
+
+  // Navigating to another page drops the takeover back to the side panel: the
+  // user asked for a page (a navbar click, an agent navigation), so the page
+  // must be what they see. Pathname only — filter and search-param changes stay
+  // on the page and keep fullscreen.
+  const { pathname } = useLocation();
+  const previousPathname = useRef(pathname);
+  useEffect(() => {
+    if (previousPathname.current === pathname) return;
+    previousPathname.current = pathname;
+    setFullscreen((current) => {
+      if (current) writeAgentFullscreen(false);
+      return false;
+    });
+  }, [pathname]);
   // A request from `openWith`, handed to the panel. `seq` makes repeat requests
   // with the same text distinct, so the panel can tell them apart.
   // Bumped by contextual ⌘J while the panel is open; the panel starts a new

apps/webapp/app/components/dashboard-agent/watch-card.test.ts

@@ -51,34 +51,34 @@ describe("the recommendations", () => {
 
   it("recommends the condition §2.1 assigns to each object", () => {
     expect(runWatchRecommendation("run_abc123").kind).toBe("run_finished");
-    expect(queueWatchRecommendation("email-sends").kind).toBe("backlog_drain");
+    expect(queueWatchRecommendation("email-sends").kind).toBe("queue_oldest_age");
     expect(errorWatchRecommendation("error_a1b2c3d4").kind).toBe("error_recurrence");
     expect(healthWatchRecommendation("warn").kind).toBe("health_recovery");
   });
 
-  // §9.1: on a queue the page already calls late, "when it drains" is the wrong
-  // promise — the useful watch is the wait itself.
-  it("switches the queue recommendation to the age SLA once runs are already late", () => {
+  // The recommendation must be a FUTURE condition: once runs are already late,
+  // "if runs wait too long" is already true and would one-shot — the useful
+  // promise flips to the recovery, "when it drains".
+  it("switches the queue recommendation to the drain once runs are already late", () => {
     const late = queueWatchRecommendation("email-sends", {
       oldestWaitMs: OLDEST_WAIT_WARNING_MS,
     });
     expect(late).toMatchObject({
-      kind: "queue_oldest_age",
+      kind: "backlog_drain",
       queue: "email-sends",
-      thresholdMinutes: OLDEST_WAIT_WARNING_MS / 60_000,
     });
     expect(watchSpecSchema.safeParse(late).success).toBe(true);
   });
 
-  it("stays on the drain when the queue is merely busy, or the signal is missing", () => {
+  it("stays on the age SLA when the queue is merely busy, or the signal is missing", () => {
     expect(
       queueWatchRecommendation("email-sends", { oldestWaitMs: OLDEST_WAIT_WARNING_MS - 1 }).kind
-    ).toBe("backlog_drain");
+    ).toBe("queue_oldest_age");
     expect(queueWatchRecommendation("email-sends", { oldestWaitMs: null }).kind).toBe(
-      "backlog_drain"
+      "queue_oldest_age"
     );
-    expect(queueWatchRecommendation("email-sends", {}).kind).toBe("backlog_drain");
-    expect(queueWatchRecommendation("email-sends").kind).toBe("backlog_drain");
+    expect(queueWatchRecommendation("email-sends", {}).kind).toBe("queue_oldest_age");
+    expect(queueWatchRecommendation("email-sends").kind).toBe("queue_oldest_age");
   });
 
   it("starts both follow-ups off — consent is never assumed", () => {
@@ -270,7 +270,7 @@ describe("the card's copy", () => {
   });
 
   it("states the condition and the duration as §2.2 writes them", () => {
-    const spec = queueWatchRecommendation("email-sends");
+    const spec = queueWatchRecommendation("email-sends", { oldestWaitMs: OLDEST_WAIT_WARNING_MS });
     expect(watchConditionLabel(spec)).toBe("Until the queue drains");
     expect(watchDurationLabel(spec)).toBe("For 1 hour · checking every 5 min");
   });
@@ -314,7 +314,7 @@ describe("the card's copy", () => {
 describe("the persisted blocks (§2.2)", () => {
   it("states all four lifetime facts on a confirmation", () => {
     const body = watchConfirmationBlockBody({
-      spec: queueWatchRecommendation("email-sends"),
+      spec: queueWatchRecommendation("email-sends", { oldestWaitMs: OLDEST_WAIT_WARNING_MS }),
       watchId: "watch_1",
     });
     expect(body.outcome).toBe("watching");

apps/webapp/app/components/dashboard-agent/watch-recommendations.ts

@@ -8,8 +8,8 @@
  * | Object | Recommendation |
  * |---|---|
  * | Run | when it finishes |
- * | Queue | when it drains — or, when runs are already waiting past the page's
- *   warning threshold, when the wait crosses the SLA |
+ * | Queue | if runs start waiting past the SLA — or, when the wait is already
+ *   past it, when the backlog drains |
  * | Error | if it happens again |
  * | Health (degraded) | when it recovers |
  *
@@ -39,30 +39,33 @@ export function runWatchRecommendation(runFriendlyId: string): WatchSpec {
 /**
  * A backlog is an aggregate, so the cadence starts at the 5-minute floor (§7.1).
  *
- * The recommendation is CONTEXTUAL: on a queue whose head-of-line run is already
- * waiting past the threshold the page tints warning at, "tell me when it drains"
- * is the wrong promise — the queue is not merely busy, runs are late, and the
- * useful watch is the wait itself. Everything else stays one tap deeper under
- * **Customize** (§2.1). The signal is threaded from the page, the same way
+ * The recommendation is CONTEXTUAL, and it must be a FUTURE condition: a watch
+ * whose condition is already true one-shots with "that already happened". On a
+ * queue whose head-of-line run is already waiting past the threshold the page
+ * tints warning at, the SLA breach is old news — the useful promise is the
+ * recovery, "tell me when it drains". On a queue that is NOT late yet, the drain
+ * may already be true (an empty queue) while "tell me if runs start waiting too
+ * long" is the thing that hasn't happened. Everything else stays one tap deeper
+ * under **Customize** (§2.1). The signal is threaded from the page, the same way
  * `degraded` is derived for the Investigate button; without it the recommendation
- * is the drain.
+ * is the SLA.
  */
 export function queueWatchRecommendation(
   queueName: string,
   context?: { oldestWaitMs?: number | null }
 ): WatchSpec {
   const oldestWaitMs = context?.oldestWaitMs ?? null;
   if (oldestWaitMs !== null && oldestWaitMs >= OLDEST_WAIT_WARNING_MS) {
-    return queueAgeWatchRecommendation(queueName);
+    return {
+      kind: "backlog_drain",
+      queue: queueName,
+      checkEveryMinutes: 5,
+      maxHours: 1,
+      note: `tell me when the ${queueName} queue drains`,
+    };
   }
 
-  return {
-    kind: "backlog_drain",
-    queue: queueName,
-    checkEveryMinutes: 5,
-    maxHours: 1,
-    note: `tell me when the ${queueName} queue drains`,
-  };
+  return queueAgeWatchRecommendation(queueName);
 }
 
 /** "Runs wait longer than N minutes" — the SLA the queue page already calls late. */

apps/webapp/app/routes/storybook.agent-ui/route.tsx

@@ -622,8 +622,9 @@ const queueStalledDraft = withVariant(queueWatchDraft, "queue_stalled");
 const queueAgeDraft = withAgeMinutes(withVariant(queueWatchDraft, "queue_oldest_age"), 5);
 
 // The contextual recommendation: on a queue whose oldest run is already waiting
-// past the page's warning threshold, the card OPENS on the age SLA instead of the
-// drain. Compact, because that is what the user sees first.
+// past the page's warning threshold the SLA is already breached, so the card
+// OPENS on the drain (the recovery) instead of the age SLA. Compact, because
+// that is what the user sees first.
 const lateQueueDraft = watchDraftFor(
   queueWatchRecommendation("email-sends", { oldestWaitMs: OLDEST_WAIT_WARNING_MS })
 );
@@ -1140,8 +1141,8 @@ const STATES: Record<string, React.ReactNode> = {
   "watch-card-queue-age": (
     <WatchCard draft={queueAgeDraft} onChange={noop} onSubmit={noop} defaultExpanded />
   ),
-  // Opened from a queue that is already late: the recommendation itself changed.
-  "watch-card-queue-age-recommended": (
+  // Opened from a queue that is already late: the recommendation flips to the drain.
+  "watch-card-queue-late-recommended": (
     <WatchCard draft={lateQueueDraft} onChange={noop} onSubmit={noop} onCancel={noop} />
   ),