fix(dashboard-agent): say a queue is paused before reciting its metrics

Metrics are a window: they cannot show a pause, and they cannot show a backlog that arrived after the window. get_queue now carries the queue's live row, and the prompt leads with it.

Author: kathiekiwi

internal-packages/dashboard-agent/GUIDEBOOK.md

@@ -93,8 +93,15 @@ So a queue full of runs shows only `Watch…` until something is actually
 executing or waiting too long — filling a queue with nothing to run it does not
 make the page degraded.
 
-**Chips in the agent panel.** An empty chat offers up to five, chosen from the
-page's live signals — a different decision from the buttons above:
+**Chips in the agent panel.** An empty chat offers up to five. They come from
+*two* places, decided separately — closing one does not close the other:
+
+*The page registry* (`suggested-prompts/page-prompts.ts`) answers by page kind
+and its fields: the queue page's "why is this backed up?" and "tell me when the
+backlog drains" live here, gated on health and on `paused`.
+
+*The page's live signals* (`suggested-prompts/signal-prompts.ts`) answer by what
+is happening on screen right now:
 
 | Signal | Chip slot |
 | --- | --- |
@@ -105,8 +112,12 @@ page's live signals — a different decision from the buttons above:
 
 A backed-up queue therefore offers "tell me when the backlog drains", never
 "investigate" — the page's own Investigate button is the one that asks that. A
-paused queue offers neither: `concurrency_saturation` is withheld while it is
-paused, for the same reason the button is.
+paused queue offers neither, in either place.
+
+So there are three sources, not two: the route's own buttons, the page registry,
+and the live signals. They look identical on screen and are decided in three
+different files — which is exactly how a rule gets fixed in one and left in the
+other two.
 
 ---
 

internal-packages/dashboard-agent/src/__snapshots__/prompt-prefix.test.ts.snap

@@ -4,34 +4,34 @@ exports[`the prefix stays inside its budget > matches the committed measurement
 {
   "assistant": {
     "prompt": {
-      "chars": 24504,
-      "estimatedTokens": 6126,
+      "chars": 24871,
+      "estimatedTokens": 6218,
     },
     "tools": {
-      "chars": 49210,
+      "chars": 49377,
       "count": 24,
-      "estimatedTokens": 12303,
+      "estimatedTokens": 12344,
     },
     "total": {
-      "chars": 73715,
-      "estimatedTokens": 18429,
-      "fingerprint": "376f30ba",
+      "chars": 74249,
+      "estimatedTokens": 18562,
+      "fingerprint": "cdd191df",
     },
   },
   "code": {
     "prompt": {
-      "chars": 27259,
-      "estimatedTokens": 6815,
+      "chars": 27626,
+      "estimatedTokens": 6907,
     },
     "tools": {
-      "chars": 52219,
+      "chars": 52386,
       "count": 28,
-      "estimatedTokens": 13055,
+      "estimatedTokens": 13097,
     },
     "total": {
-      "chars": 79479,
-      "estimatedTokens": 19870,
-      "fingerprint": "2cdf079b",
+      "chars": 80013,
+      "estimatedTokens": 20003,
+      "fingerprint": "4a1d2f84",
     },
   },
 }

internal-packages/dashboard-agent/src/tool-api.ts

@@ -69,6 +69,29 @@ export function queueMetricsAreEmpty(data: unknown): boolean {
   );
 }
 
+/**
+ * Metrics plus the queue's live row. `paused` is the part the model must lead with: a queue
+ * someone stopped explains its own emptiness, and every metric below it is a consequence
+ * rather than a finding.
+ */
+function withLiveState(
+  metrics: unknown,
+  queueType: "task" | "custom",
+  state: Record<string, unknown> | undefined
+) {
+  const row = (state as { data?: Record<string, unknown> })?.data ?? state;
+  if (!row) return { ...(metrics as object), queueType, exists: false };
+  return {
+    ...(metrics as object),
+    queueType: (row.type as string) ?? queueType,
+    exists: true,
+    paused: Boolean(row.paused),
+    queuedNow: row.queued ?? null,
+    runningNow: row.running ?? null,
+    concurrencyLimit: row.concurrencyLimit ?? null,
+  };
+}
+
 export function buildApiTools(args: {
   ctx: DashboardAgentToolContext;
   client: DashboardAgentApiClient;
@@ -356,6 +379,16 @@ export function buildApiTools(args: {
           return result;
         };
 
+        // Live state first: metrics are a window, and a window can't say "paused" or show a
+        // backlog that arrived after it. A queue nobody is running is not the same as a queue
+        // someone stopped, and the answer has to lead with which one it is.
+        const live = async (kind: "task" | "custom") => {
+          const result = await envApiGet(
+            `/api/v1/queues/${encodeURIComponent(queue)}?type=${kind}`
+          );
+          return result?.ok ? (result.data as Record<string, unknown>) : undefined;
+        };
+
         const first = await read(type ?? "task");
         if (!first) return { error: "No current environment is available to read queues from." };
         if (!first.ok) {
@@ -364,12 +397,19 @@ export function buildApiTools(args: {
           };
         }
         if (queueMetricsAreEmpty(first.data)) {
-          const other = await read(type === "custom" ? "task" : "custom");
+          const otherKind = type === "custom" ? "task" : "custom";
+          const other = await read(otherKind);
           if (other?.ok && !queueMetricsAreEmpty(other.data)) {
-            return { ...(other.data as object), queueType: type === "custom" ? "task" : "custom" };
+            return withLiveState(other.data, otherKind, await live(otherKind));
           }
+          // Neither kind has metrics, so the live row is the only thing that can tell them
+          // apart: a paused or empty queue that exists, against a name that doesn't.
+          const kind = type ?? "task";
+          const state = (await live(kind)) ?? (await live(otherKind));
+          return withLiveState(first.data, kind, state);
         }
-        return { ...(first.data as object), queueType: type ?? "task" };
+        const kind = type ?? "task";
+        return withLiveState(first.data, kind, await live(kind));
       },
     }),
 

internal-packages/dashboard-agent/src/tool-schemas.ts

@@ -175,7 +175,7 @@ export const getReportSchema = tool({
 
 export const getQueueSchema = tool({
   description:
-    "Get one queue's metrics over a window: wait latency (p50/p95), peak depth, how many runs started (throughput), and how often the queue was throttled by its concurrency limit. Use this for 'how deep is the X queue', 'is X backed up', or 'why are runs waiting'.",
+    "Get one queue's metrics over a window: wait latency (p50/p95), peak depth, how many runs started (throughput), and how often the queue was throttled by its concurrency limit. Use this for 'how deep is the X queue', 'is X backed up', or 'why are runs waiting'. The answer also carries the queue's live row: `paused`, `queuedNow`, `runningNow`, `concurrencyLimit`, and `exists: false` when no queue of that name is there at all.",
   inputSchema: z.object({
     queue: z
       .string()
@@ -468,7 +468,7 @@ You have read-only tools that act as the user against their own account:
 - ask_support: ask the Trigger.dev support assistant about how Trigger.dev works (docs, concepts, features, configuration, how-tos).
 - render_view: render a structured view in the panel from the block catalog. The catalog has the "diagnosis" block (a failure card for a single run), the "chart" block (a line/bar chart of run_query results), the "actions" block (a row of 1-3 buttons offering next steps — a watch intent opens the watch card pre-filled, an ask intent sends the labelled question as the user's next message), and the "investigation" block (a live card for a hypothesis-driven investigation).
 - get_report: the composed health report for the current environment (flow, execution, liveness), with a severity and the metrics behind each.
-- get_queue: one queue's wait latency, peak depth, throughput, and throttling over a window.
+- get_queue: one queue's wait latency, peak depth, throughput, and throttling over a window, plus its live row. Lead with paused when it is true: a paused queue explains its own emptiness, and every metric under it is a consequence, not a finding — say it is paused, and only then the numbers. queuedNow is what is waiting right now, which a window of metrics cannot show; exists:false is the only thing that means the queue isn't there, never zeroed metrics.
 - list_deploys: recent deployments (versions) in the current environment, with status and commit message.
 - get_deploy: one deployment's detail, or the current promoted one when you omit the version.
 - correlate_version: the version, commit, and pull request a specific run actually ran.