feat(webapp): deterministic grounding facts and org-wide tokens for the dashboard agent

.changeset/chat-session-run-ttl.md

@@ -0,0 +1,6 @@
+---
+"@trigger.dev/core": patch
+"@trigger.dev/sdk": patch
+---
+
+Chat server sessions can now set a `ttl` on the runs they trigger, so a run that is never picked up expires instead of waiting indefinitely.

.server-changes/agent-chat-code-renderer-fallback.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Fix the assistant chat showing a full-screen error when code highlighting fails to load. It now retries automatically and falls back to plain text so the conversation stays usable.

.server-changes/agent-grounded-queue-answers.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+The AI assistant now gives grounded answers about queues: it can name the exact runs occupying concurrency slots and which limit is blocking, report accurate queue wait times, and help across all projects in your organization.

.server-changes/dashboard-agent-bounded-wait-errors.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+The dashboard agent chat no longer waits forever on a stuck response or tool call — it now shows a clear error with a "Try again" option instead of hanging silently.

apps/webapp/app/components/code/StreamdownRenderer.test.ts

@@ -1,7 +1,12 @@
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
-import { describe, expect, it } from "vitest";
-import { restrictModelUrls, StreamdownRenderer } from "./StreamdownRenderer";
+import { describe, expect, it, vi } from "vitest";
+import {
+  loadStreamdownRenderer,
+  restrictModelUrls,
+  retryImport,
+  StreamdownRenderer,
+} from "./StreamdownRenderer";
 
 // streamdown calls urlTransform(url, key, node) to compute each url attribute; a
 // returned undefined removes the attribute, so no request is ever issued.
@@ -88,3 +93,53 @@ describe("StreamdownRenderer (rendered markdown)", () => {
     expect(html).toContain('src="/local/pic.png"');
   });
 });
+
+describe("retryImport", () => {
+  it("resolves on first success", async () => {
+    const importer = vi.fn().mockResolvedValue("ok");
+    await expect(retryImport(importer, [0, 0])).resolves.toBe("ok");
+    expect(importer).toHaveBeenCalledTimes(1);
+  });
+
+  it("retries after failures then succeeds", async () => {
+    const importer = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("fail1"))
+      .mockRejectedValueOnce(new Error("fail2"))
+      .mockResolvedValue("ok");
+    await expect(retryImport(importer, [0, 0])).resolves.toBe("ok");
+    expect(importer).toHaveBeenCalledTimes(3);
+  });
+
+  it("throws after exhausting retries", async () => {
+    const importer = vi.fn().mockRejectedValue(new Error("always fails"));
+    await expect(retryImport(importer, [0, 0])).rejects.toThrow("always fails");
+    expect(importer).toHaveBeenCalledTimes(3);
+  });
+});
+
+describe("loadStreamdownRenderer", () => {
+  it("resolves to a plain-text fallback when the chunk load keeps failing", async () => {
+    // The fallback path re-raises as an unhandled rejection (for StaleAssetRecovery); swap
+    // in our own listener so it's asserted on, not reported as a test-runner failure.
+    const priorListeners = process.listeners("unhandledRejection");
+    process.removeAllListeners("unhandledRejection");
+    const caught = new Promise<Error>((resolve) => {
+      process.once("unhandledRejection", (err) => resolve(err as Error));
+    });
+
+    try {
+      const mod = await loadStreamdownRenderer(() => Promise.reject(new Error("boom")), [0, 0]);
+      const html = renderToStaticMarkup(createElement(mod.default, null, "hello **world**"));
+      expect(html).toContain("hello");
+
+      const dispatched = await caught;
+      expect(dispatched.message).toMatch(/boom/);
+    } finally {
+      process.removeAllListeners("unhandledRejection");
+      for (const listener of priorListeners) {
+        process.on("unhandledRejection", listener as NodeJS.UnhandledRejectionListener);
+      }
+    }
+  });
+});

apps/webapp/app/components/code/StreamdownRenderer.tsx

@@ -1,5 +1,8 @@
 import { lazy } from "react";
 import type { CodeHighlighterPlugin, UrlTransform } from "streamdown";
+import type * as StreamdownModule from "streamdown";
+import type * as StreamdownCodeModule from "@streamdown/code";
+import type * as ShikiThemeModule from "./shikiTheme";
 
 const SAFE_LINK_SCHEMES = new Set(["http:", "https:", "mailto:"]);
 
@@ -35,9 +38,41 @@ export const restrictModelUrls: UrlTransform = (url, key, node) => {
   return SAFE_LINK_SCHEMES.has(`${schemeMatch[1].toLowerCase()}:`) ? url : undefined;
 };
 
-export const StreamdownRenderer = lazy(() =>
-  Promise.all([import("streamdown"), import("@streamdown/code"), import("./shikiTheme")]).then(
-    ([{ Streamdown }, { createCodePlugin }, { triggerDarkTheme }]) => {
+const RETRY_DELAYS_MS = [250, 1000];
+
+/** Retries a lazy import a few times before giving up, so a flaky chunk load doesn't crash the chat. */
+export async function retryImport<T>(
+  importer: () => Promise<T>,
+  delaysMs: number[] = RETRY_DELAYS_MS
+): Promise<T> {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await importer();
+    } catch (error) {
+      if (attempt >= delaysMs.length) {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delaysMs[attempt]));
+    }
+  }
+}
+
+const PlainTextFallback = ({ children }: { children: string }) => (
+  <pre className="whitespace-pre-wrap break-words font-sans text-sm">{children}</pre>
+);
+
+type StreamdownRendererModule = {
+  default: (props: { children: string; isAnimating?: boolean }) => JSX.Element;
+};
+
+export function loadStreamdownRenderer(
+  load: () => Promise<
+    [typeof StreamdownModule, typeof StreamdownCodeModule, typeof ShikiThemeModule]
+  > = () => Promise.all([import("streamdown"), import("@streamdown/code"), import("./shikiTheme")]),
+  delaysMs?: number[]
+): Promise<StreamdownRendererModule> {
+  return retryImport(load, delaysMs)
+    .then(([{ Streamdown }, { createCodePlugin }, { triggerDarkTheme }]) => {
       // Type assertion needed: @streamdown/code and streamdown resolve different shiki
       // versions under pnpm, causing structurally-identical CodeHighlighterPlugin types
       // to be considered incompatible (different BundledLanguage string unions).
@@ -64,6 +99,12 @@ export const StreamdownRenderer = lazy(() =>
           </Streamdown>
         ),
       };
-    }
-  )
-);
+    })
+    .catch((error) => {
+      // Re-raise as an unhandled rejection so StaleAssetRecovery can reload on deploy skew.
+      queueMicrotask(() => void Promise.reject(error));
+      return { default: PlainTextFallback };
+    });
+}
+
+export const StreamdownRenderer = lazy(() => loadStreamdownRenderer());

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

@@ -9,7 +9,7 @@ import {
 } from "@internal/dashboard-agent-contracts";
 import { useLocation, useNavigate } from "@remix-run/react";
 import { useTriggerChatTransport } from "@trigger.dev/sdk/chat/react";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useToast } from "~/components/primitives/Toast";
 import { AgentQuotaNotice, AgentUpgradeBlock } from "./AgentUpgradeGate";
 import { DashboardAgentComposer } from "./DashboardAgentComposer";
@@ -27,15 +27,25 @@ import { createTranscriptOrder, orderTranscript } from "./message-order";
 import { navigateDestination } from "./navigate-target";
 import { pendingNavigateIntents, pendingWatchIntents } from "./pending-intents";
 import type { AgentPageContext } from "./page-context-types";
+import { inFlightToolName } from "./progress-line";
 import { retryAction } from "./retry-action";
 import {
   fetchChatTranscript,
   pollSettledTranscript,
   transcriptLooksUnfinished,
 } from "./settled-transcript";
+import { toolPendingLabel } from "./tool-labels";
 import { takeNavigateIntent } from "./turn-navigation";
 import { sendRequestOutcome } from "./send-request";
 import { teardownCancelsTurn, unmountTeardown } from "./turn-teardown";
+import {
+  activeToolPendingKey,
+  createKeyedDeadline,
+  FIRST_EVENT_DEADLINE_MS,
+  TOOL_PENDING_DEADLINE_MS,
+  turnDeadlineErrorMessage,
+  type TurnDeadlineError,
+} from "./turn-deadlines";
 import { useAgentMessageQuota } from "./useAgentMessageQuota";
 import { useTriggerUriResolver } from "./useTriggerUriResolver";
 import { WatchChips, type WatchChip } from "./WatchChips";
@@ -80,6 +90,8 @@ export function DashboardAgentChat({
   onTurnSettled,
   onActivityChange,
   onQuotaChange,
+  firstEventDeadlineMs = FIRST_EVENT_DEADLINE_MS,
+  toolPendingDeadlineMs = TOOL_PENDING_DEADLINE_MS,
 }: {
   chatId: string;
   initialMessages: UIMessage[];
@@ -102,13 +114,18 @@ export function DashboardAgentChat({
   pagePaths?: Record<string, string>;
   watchCard?: React.ReactNode;
   appendedMessages?: { messages: UIMessage[]; seq: number };
-  /** Nothing is persisted until the user submits the card. */
-  onWatchIntent?: (spec: WatchSpec) => void;
+  /** Nothing is persisted until the user submits the card. `target` is set only when
+   * the watch targets another project/environment than this chat's own. */
+  onWatchIntent?: (spec: WatchSpec, target?: { environmentId: string }) => void;
   onCancelWatch: (watchId: string) => void;
   onTurnSettled: () => void;
   onActivityChange?: (chatId: string, activity: TurnActivity | null) => void;
   /** The poll lives here, so this is where the panel learns the cap has lifted. */
   onQuotaChange?: (quota: MessageQuota) => void;
+  /** How long to wait for the first stream event before showing a bounded-wait error. */
+  firstEventDeadlineMs?: number;
+  /** How long a single pending tool call can run before showing a bounded-wait error. */
+  toolPendingDeadlineMs?: number;
 }) {
   const [input, setInput] = useState("");
   // Set when the server refuses a send over the cap, so the block shows at once rather than
@@ -213,6 +230,53 @@ export function DashboardAgentChat({
 
   const messages = orderTranscript(rawMessages, orderRef.current);
 
+  // Independent of the SDK's own `error`: both drive the live-error callout, but a
+  // deadline firing never touches the server turn or `status`.
+  const [deadlineError, setDeadlineError] = useState<TurnDeadlineError | null>(null);
+  // Bumped in `retry` to force the first-event effect to re-run when a resend reuses the
+  // same `status: "submitted"`. `dismissError` never bumps it.
+  const [attempt, setAttempt] = useState(0);
+  const firstEventDeadline = useRef(
+    createKeyedDeadline<"submitted">({
+      deadlineMs: firstEventDeadlineMs,
+      onTimeout: () => setDeadlineError({ kind: "first-event" }),
+      onClear: () =>
+        setDeadlineError((current) => (current?.kind === "first-event" ? null : current)),
+    })
+  ).current;
+  const toolPendingDeadline = useRef(
+    createKeyedDeadline<string>({
+      deadlineMs: toolPendingDeadlineMs,
+      onTimeout: (tool) => setDeadlineError({ kind: "tool-pending", tool }),
+      onClear: () =>
+        setDeadlineError((current) => (current?.kind === "tool-pending" ? null : current)),
+    })
+  ).current;
+  useEffect(() => {
+    firstEventDeadline.sync(status === "submitted" ? "submitted" : null);
+    // `attempt` forces a re-sync when `status` is unchanged across a retry (see its
+    // declaration above).
+  }, [status, firstEventDeadline, attempt]);
+  useEffect(() => {
+    toolPendingDeadline.sync(activeToolPendingKey(status, inFlightToolName(messages)));
+  }, [messages, status, toolPendingDeadline]);
+  useEffect(
+    () => () => {
+      firstEventDeadline.dispose();
+      toolPendingDeadline.dispose();
+    },
+    [firstEventDeadline, toolPendingDeadline]
+  );
+  // The SDK's own error wins when both are present — it's the more specific failure.
+  const effectiveError = useMemo(
+    () =>
+      error ??
+      (deadlineError
+        ? new Error(turnDeadlineErrorMessage(deadlineError, toolPendingLabel))
+        : undefined),
+    [error, deadlineError]
+  );
+
   // Read here, not in the panel, so it re-reads as each turn settles.
   const quota = useAgentMessageQuota({ actionPath, chatId, status });
   useEffect(() => {
@@ -299,13 +363,36 @@ export function DashboardAgentChat({
     );
     if (!action) return;
     clearError();
+    setDeadlineError(null);
+    // Reset the deadlines' own key, not just the displayed error: a dangling tool part
+    // that already fired once would otherwise never re-arm (same key, no change to sync).
+    firstEventDeadline.sync(null);
+    toolPendingDeadline.sync(null);
+    // Forces the first-event effect to re-sync even when `status` stays "submitted" across
+    // the retry (a resend re-enters "submitted", the same value the failed turn left it in).
+    setAttempt((current) => current + 1);
     turnStartedPathRef.current = renderedPathRef.current;
     if (action.kind === "regenerate") {
       void regenerate();
       return;
     }
     void sendMessage({ text: action.text, messageId: action.messageId });
-  }, [messages, sendMessage, regenerate, clearError, atMessageCap]);
+  }, [
+    messages,
+    sendMessage,
+    regenerate,
+    clearError,
+    atMessageCap,
+    firstEventDeadline,
+    toolPendingDeadline,
+  ]);
+
+  const dismissError = useCallback(() => {
+    clearError();
+    setDeadlineError(null);
+    firstEventDeadline.sync(null);
+    toolPendingDeadline.sync(null);
+  }, [clearError, firstEventDeadline, toolPendingDeadline]);
 
   const resolveUri = useTriggerUriResolver(actionPath);
 
@@ -345,7 +432,10 @@ export function DashboardAgentChat({
           submit(intent.prompt);
           return;
         case "watch":
-          onWatchIntent?.(intent.spec);
+          onWatchIntent?.(
+            intent.spec,
+            intent.target ? { environmentId: intent.target.environmentId } : undefined
+          );
           return;
         case "navigate":
           void goTo(intent);
@@ -383,7 +473,12 @@ export function DashboardAgentChat({
   useEffect(() => {
     const pending = pendingWatchIntents(messages, watchProposedRef.current!);
     const proposed = pending.at(-1);
-    if (proposed) onWatchIntent?.(proposed.spec);
+    if (proposed) {
+      onWatchIntent?.(
+        proposed.spec,
+        proposed.target ? { environmentId: proposed.target.environmentId } : undefined
+      );
+    }
   }, [messages, onWatchIntent]);
 
   const stop = useCallback(() => {
@@ -450,10 +545,10 @@ export function DashboardAgentChat({
         <DashboardAgentMessages
           messages={messages}
           activity={activity}
-          error={error}
+          error={effectiveError}
           onRetry={retry}
           retryDisabledReason={atMessageCap ? MESSAGE_QUOTA_REACHED_REASON : undefined}
-          onDismissError={clearError}
+          onDismissError={dismissError}
           onIntent={handleIntent}
           pagePaths={pagePaths}
           watches={watches}

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

@@ -409,10 +409,10 @@ export function DashboardAgentPanel({
   }, [watchRequest]);
 
   // Nothing is posted or persisted until the card is submitted.
-  const openWatchCard = useCallback((spec: WatchSpec) => {
+  const openWatchCard = useCallback((spec: WatchSpec, target?: { environmentId: string }) => {
     dispatchWatchCard({
       type: "open",
-      draft: watchDraftFor(spec),
+      draft: watchDraftFor(spec, target),
       requestId: generateFriendlyId("wreq"),
     });
   }, []);

apps/webapp/app/components/dashboard-agent/InvestigationCard.render.test.ts

@@ -66,6 +66,17 @@ describe("the card's sections appear only when they have something in them", ()
     expect(html).toContain("Hypotheses");
     expect(html).toContain("The receipt builder is handed a null order id.");
   });
+
+  it("leaves out the hypotheses count on the toggle when there are none", () => {
+    const html = markup({ block: block({}) });
+    expect(html).not.toContain("hypothesis");
+    expect(html).not.toContain("hypotheses");
+  });
+
+  it("shows the hypotheses count on the toggle once there is one", () => {
+    const html = markup({ block: block({ hypotheses: [HYPOTHESIS] }) });
+    expect(html).toContain("1 hypothesis");
+  });
 });
 
 describe("action buttons need a host to hand the intent to", () => {