diff --git a/.changeset/dashboard-agent-chat-streams.md b/.changeset/dashboard-agent-chat-streams.md
new file mode 100644
index 0000000000..a6dc7d1880
--- /dev/null
+++ b/.changeset/dashboard-agent-chat-streams.md
@@ -0,0 +1,5 @@
+---
+"@trigger.dev/sdk": patch
+---
+
+Watch-mode chat streams now survive quiet windows and page reloads, and a reply cut off by a lost connection shows an error instead of appearing finished. Aborting a resumed subscription only closes your local stream — call `stopGeneration(chatId)` or pass `stopOnAbort: true` to stop the run. Also fixed a race where quickly restarting a stream could break stop and reconnect, and stopping a chat now hands it back to your other tabs instead of leaving them read-only.
diff --git a/.server-changes/agent-plan-limits.md b/.server-changes/agent-plan-limits.md
new file mode 100644
index 0000000000..36e66bd02b
--- /dev/null
+++ b/.server-changes/agent-plan-limits.md
@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+The dashboard agent now has a monthly message allowance and plan-based limits on watches. Queries stay read-only with clearer errors when busy, and messages with unusual characters no longer fail to send.
diff --git a/apps/webapp/app/components/dashboard-agent/AgentUpgradeGate.tsx b/apps/webapp/app/components/dashboard-agent/AgentUpgradeGate.tsx
index 4b795edde9..70a5da7b82 100644
--- a/apps/webapp/app/components/dashboard-agent/AgentUpgradeGate.tsx
+++ b/apps/webapp/app/components/dashboard-agent/AgentUpgradeGate.tsx
@@ -1,18 +1,21 @@
import { Link } from "@remix-run/react";
+import { AgentMonoLogo } from "~/components/primitives/AgentDotMatrix";
import { LinkButton } from "~/components/primitives/Buttons";
import { useOrganization } from "~/hooks/useOrganizations";
-import { cn } from "~/utils/cn";
import { v3BillingPath } from "~/utils/pathBuilder";
-import { AgentIcon, AGENT_ICON_ACCENT_CLASS, ASK_AGENT_LABEL } from "./agent-identity";
+import { ASK_AGENT_LABEL } from "./agent-identity";
+import { messageQuotaReachedCopy } from "./message-quota";
// Matches the composer's outer geometry so the replacement lands in the same place.
const SLOT = "flex shrink-0 flex-col bg-background-bright px-3 pb-3 pt-1";
export function AgentUpgradeBlock({
limit,
+ planResolved,
context,
}: {
limit: number;
+ planResolved: boolean;
context?: React.ReactNode;
}) {
const organization = useOrganization();
@@ -22,14 +25,12 @@ export function AgentUpgradeBlock({
{context}
-
+
Upgrade to unlock {ASK_AGENT_LABEL}
-
- You've used all {limit} messages included on the Free plan. Your chats stay here to read.
-
+
{messageQuotaReachedCopy(limit, planResolved)}
Upgrade
diff --git a/apps/webapp/app/components/dashboard-agent/DashboardAgentChat.tsx b/apps/webapp/app/components/dashboard-agent/DashboardAgentChat.tsx
index 19e65a570c..bd1404e742 100644
--- a/apps/webapp/app/components/dashboard-agent/DashboardAgentChat.tsx
+++ b/apps/webapp/app/components/dashboard-agent/DashboardAgentChat.tsx
@@ -17,6 +17,12 @@ import { DashboardAgentContextBanner } from "./DashboardAgentContextBanner";
import { DashboardAgentHero } from "./DashboardAgentHero";
import { DashboardAgentMessages, type TurnActivity } from "./DashboardAgentMessages";
import { MESSAGE_TOO_LARGE_ERROR } from "./message-limits";
+import {
+ FREE_PLAN_MESSAGE_LIMIT,
+ MESSAGE_QUOTA_REACHED_REASON,
+ parseQuotaReachedResponse,
+ type MessageQuota,
+} from "./message-quota";
import { createTranscriptOrder, orderTranscript } from "./message-order";
import { navigateDestination } from "./navigate-target";
import { pendingNavigateIntents, pendingWatchIntents } from "./pending-intents";
@@ -73,6 +79,7 @@ export function DashboardAgentChat({
onCancelWatch,
onTurnSettled,
onActivityChange,
+ onQuotaChange,
}: {
chatId: string;
initialMessages: UIMessage[];
@@ -100,8 +107,15 @@ export function DashboardAgentChat({
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;
}) {
const [input, setInput] = useState("");
+ // Set when the server refuses a send over the cap, so the block shows at once rather than
+ // waiting for the next quota poll.
+ const [quotaReached, setQuotaReached] = useState<{ limit: number; planResolved: boolean } | null>(
+ null
+ );
const navigate = useNavigate();
const location = useLocation();
const toast = useToast();
@@ -128,6 +142,18 @@ export function DashboardAgentChat({
.catch(() => null)) as { error?: string } | null;
throw new Error(data?.error ?? MESSAGE_TOO_LARGE_ERROR);
}
+ // Over the message cap: show the upgrade block instead of a generic turn error.
+ if (res.status === 403) {
+ const data = (await res
+ .clone()
+ .json()
+ .catch(() => null)) as { error?: string; limit?: number } | null;
+ const reached = parseQuotaReachedResponse(res.status, data);
+ if (reached) {
+ setQuotaReached(reached);
+ throw new Error("You've reached your message limit.");
+ }
+ }
return res;
},
clientData,
@@ -185,9 +211,20 @@ export function DashboardAgentChat({
const orderRef = useRef(createTranscriptOrder(initialMessages));
const messages = orderTranscript(rawMessages, orderRef.current);
- // Counted here, not in the panel, so it includes the turn just sent.
- const quota = useAgentMessageQuota({ actionPath, chatId, messages });
- const atMessageCap = quota.kind === "reached";
+ // Read here, not in the panel, so it re-reads as each turn settles.
+ const quota = useAgentMessageQuota({ actionPath, chatId, status });
+ useEffect(() => {
+ onQuotaChange?.(quota);
+ // The quota object is rebuilt every render; only its kind is acted on.
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ }, [quota.kind, onQuotaChange]);
+ // Either the poll saw the cap, or a send was just refused over it.
+ const atMessageCap = quota.kind === "reached" || quotaReached !== null;
+ const messageCapLimit =
+ quotaReached?.limit ?? (quota.kind === "unlimited" ? FREE_PLAN_MESSAGE_LIMIT : quota.limit);
+ // The poll only runs on the free plan, so its cap is the free-plan nudge; a refusal
+ // carries the plan limit the server resolved.
+ const messageCapPlanResolved = quotaReached?.planResolved ?? false;
const isStreaming = status === "streaming";
// From status, not the last part: the indicator must stay up through silent tool calls.
@@ -252,6 +289,8 @@ export function DashboardAgentChat({
}, [sendRequest, submit, canSend]);
const retry = useCallback(() => {
+ // Over the cap, a retry only earns another 403 — same guard as `submit`.
+ if (atMessageCap) return;
// A watch's consent record is a user message nobody typed, so retry never treats it as one.
const action = retryAction(
messages.filter((m) => !(m.role === "user" && isWatchRequestMessageId(m.id)))
@@ -264,7 +303,7 @@ export function DashboardAgentChat({
return;
}
void sendMessage({ text: action.text, messageId: action.messageId });
- }, [messages, sendMessage, regenerate, clearError]);
+ }, [messages, sendMessage, regenerate, clearError, atMessageCap]);
const resolveUri = useTriggerUriResolver(actionPath);
@@ -399,6 +438,7 @@ export function DashboardAgentChat({
onSelect={submit}
pageContext={clientData.pageContext}
promoted={promotedPrompt}
+ promptsDisabledReason={atMessageCap ? MESSAGE_QUOTA_REACHED_REASON : undefined}
/>
) : (
)}
{watchCard ?
{watchCard}
: null}
- {quota.kind === "reached" ? (
+ {atMessageCap ? (
{
escapeGuardArmed.current = true;
- onChange(e.target.value.slice(0, MAX_MESSAGE_CHARS));
+ onChange(sliceWellFormed(e.target.value, MAX_MESSAGE_CHARS));
}}
onBlur={() => {
escapeGuardArmed.current = true;
diff --git a/apps/webapp/app/components/dashboard-agent/DashboardAgentDraft.tsx b/apps/webapp/app/components/dashboard-agent/DashboardAgentDraft.tsx
index 9698329abc..d7dcfabcc5 100644
--- a/apps/webapp/app/components/dashboard-agent/DashboardAgentDraft.tsx
+++ b/apps/webapp/app/components/dashboard-agent/DashboardAgentDraft.tsx
@@ -1,8 +1,10 @@
import type { SuggestedPrompt } from "@internal/dashboard-agent-contracts";
import { useCallback, useMemo, useState } from "react";
+import { AgentUpgradeBlock } from "./AgentUpgradeGate";
import { DashboardAgentComposer } from "./DashboardAgentComposer";
import { DashboardAgentContextBanner } from "./DashboardAgentContextBanner";
import { DashboardAgentHero } from "./DashboardAgentHero";
+import { MESSAGE_QUOTA_REACHED_REASON } from "./message-quota";
import type { AgentPageContext } from "./page-context-types";
import { readDismissedPromptIds, resolveSuggestedPromptsBySlot } from "./suggested-prompts";
@@ -16,6 +18,7 @@ export function DashboardAgentDraft({
pageContext,
promotedPrompt,
watchCard,
+ capReached,
}: {
onSubmit: (text: string) => void;
projectSlug: string;
@@ -24,6 +27,7 @@ export function DashboardAgentDraft({
pageContext?: AgentPageContext;
promotedPrompt?: SuggestedPrompt;
watchCard?: React.ReactNode;
+ capReached?: { limit: number; planResolved: boolean } | null;
}) {
const [input, setInput] = useState("");
@@ -43,12 +47,14 @@ export function DashboardAgentDraft({
const submit = useCallback(
(text: string) => {
+ // Suggested prompts reach here via the hero, bypassing the composer's cap guard.
+ if (capReached) return;
const trimmed = text.trim();
if (!trimmed) return;
setInput("");
onSubmit(trimmed);
},
- [onSubmit]
+ [onSubmit, capReached]
);
return (
@@ -56,26 +62,44 @@ export function DashboardAgentDraft({
onSelect={submit}
pageContext={pageContext}
promoted={promotedPrompt}
+ promptsDisabledReason={capReached ? MESSAGE_QUOTA_REACHED_REASON : undefined}
composer={
-
+ )
}
/>
);
diff --git a/apps/webapp/app/components/dashboard-agent/DashboardAgentHero.tsx b/apps/webapp/app/components/dashboard-agent/DashboardAgentHero.tsx
index 15d399b37f..6695f3cda9 100644
--- a/apps/webapp/app/components/dashboard-agent/DashboardAgentHero.tsx
+++ b/apps/webapp/app/components/dashboard-agent/DashboardAgentHero.tsx
@@ -11,6 +11,7 @@ export function DashboardAgentHero({
promoted,
dismissedIds,
composer,
+ promptsDisabledReason,
}: {
/** Receives the prompt text to send, not the button label. */
onSelect: (prompt: string) => void;
@@ -18,6 +19,8 @@ export function DashboardAgentHero({
promoted?: SuggestedPrompt;
dismissedIds?: string[];
composer?: React.ReactNode;
+ /** Set to disable the suggestion chips and say why. */
+ promptsDisabledReason?: string;
}) {
// Centred by the child's `m-auto`, not by `justify-center`: auto margins give up their space
// once the content outgrows the panel, so the heading stays scrollable to.
@@ -40,6 +43,7 @@ export function DashboardAgentHero({
pageContext={pageContext}
promoted={promoted}
dismissedIds={dismissedIds}
+ disabledReason={promptsDisabledReason}
/>
diff --git a/apps/webapp/app/components/dashboard-agent/DashboardAgentMessages.tsx b/apps/webapp/app/components/dashboard-agent/DashboardAgentMessages.tsx
index 6ec77399aa..ab8d9656ec 100644
--- a/apps/webapp/app/components/dashboard-agent/DashboardAgentMessages.tsx
+++ b/apps/webapp/app/components/dashboard-agent/DashboardAgentMessages.tsx
@@ -35,6 +35,8 @@ export type DashboardAgentMessagesProps = {
activity: TurnActivity | null;
error?: Error;
onRetry?: () => void;
+ /** Set to disable the retry button and say why, e.g. over the message cap. */
+ retryDisabledReason?: string;
onDismissError?: () => void;
onIntent?: (intent: AgentIntent) => void;
resolveUri?: (uri: string) => ResolvedUri | null;
@@ -356,6 +358,7 @@ export function DashboardAgentTurns({
activity,
error,
onRetry,
+ retryDisabledReason,
onDismissError,
onIntent,
resolveUri,
@@ -402,7 +405,16 @@ export function DashboardAgentTurns({
(onRetry || onDismissError) && (
{onRetry && (
-
diff --git a/apps/webapp/app/components/dashboard-agent/demo/components/DemoChartCard.tsx b/apps/webapp/app/components/dashboard-agent/demo/components/DemoChartCard.tsx
new file mode 100644
index 0000000000..bd45153d95
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/components/DemoChartCard.tsx
@@ -0,0 +1,32 @@
+import type { AgentIntent, ChartAction } from "@internal/dashboard-agent-contracts";
+import { QueryResultsChart } from "~/components/code/QueryResultsChart";
+import { AGENT_CHART_PLOT_CLASS, ChartActions } from "../../AgentChart";
+import { AgentCard, AgentCardHeader } from "../../agent-card";
+import { demoChart } from "../fixtures/chart";
+
+export function DemoChartCard({
+ title = demoChart.title,
+ actions,
+ onIntent,
+}: {
+ title?: string;
+ actions?: ChartAction[];
+ onIntent?: (intent: AgentIntent) => void;
+}) {
+ return (
+
+ {title ? (
+ {title}
+ ) : null}
+
+
+
+
+
+ );
+}
diff --git a/apps/webapp/app/components/dashboard-agent/demo/components/DemoIntentBubble.tsx b/apps/webapp/app/components/dashboard-agent/demo/components/DemoIntentBubble.tsx
new file mode 100644
index 0000000000..c2f1820750
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/components/DemoIntentBubble.tsx
@@ -0,0 +1,60 @@
+import {
+ ArrowTopRightOnSquareIcon,
+ CheckCircleIcon,
+ NoSymbolIcon,
+} from "@heroicons/react/20/solid";
+import { Button } from "~/components/primitives/Buttons";
+import { cn } from "~/utils/cn";
+import { AgentStatusIcon } from "../../agent-badges";
+import { ChatStatusLine } from "../../chat-layout";
+import type { DemoIntent } from "../fixtures/intents";
+
+export function DemoIntentBubble({
+ intent,
+ onIntercept,
+}: {
+ intent: DemoIntent;
+ onIntercept?: (message: string) => void;
+}) {
+ const rejected = !intent.executable;
+
+ return (
+
+
+ }
+ >
+
{intent.outcome}
+ {intent.deepLinkLabel ? (
+
+ ) : null}
+
+
+ );
+}
diff --git a/apps/webapp/app/components/dashboard-agent/demo/demo.test.ts b/apps/webapp/app/components/dashboard-agent/demo/demo.test.ts
new file mode 100644
index 0000000000..e9bb746dcc
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/demo.test.ts
@@ -0,0 +1,352 @@
+import {
+ agentIntentSchema,
+ agentPageContextSchema,
+ isRevisableBlock,
+ safeParseStoredViewBlock,
+ safeParseTriggerUri,
+ suggestedPromptSchema,
+ viewBlockSchema,
+ watchIdentity,
+ watchSpecSchema,
+ SUGGESTED_PROMPT_CAP,
+ type Evidence,
+} from "@internal/dashboard-agent-contracts";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { resolveSuggestedPrompts } from "../suggested-prompts";
+import * as fixtures from "./fixtures";
+import { DEMO_ID_PREFIX, DEMO_MARKER, demoSourceUri } from "./ids";
+
+const DEMO_DIR = __dirname;
+
+function walk(dir: string): string[] {
+ return readdirSync(dir).flatMap((entry) => {
+ const path = join(dir, entry);
+ return statSync(path).isDirectory() ? walk(path) : [path];
+ });
+}
+
+const sourceFiles = walk(DEMO_DIR).filter(
+ (path) => /\.(ts|tsx)$/.test(path) && !path.endsWith(".test.ts")
+);
+
+function importSpecifiers(source: string): string[] {
+ return [
+ ...source.matchAll(/(?:import|export)[\s\S]*?from\s+["']([^"']+)["']/g),
+ // A side-effect or dynamic import binds nothing, so it never reaches a `from`.
+ ...source.matchAll(/\bimport\s*\(?\s*["']([^"']+)["']/g),
+ ].map((match) => match[1]!);
+}
+
+describe("demo ids", () => {
+ it("namespaces investigation, hypothesis, watch and prompt ids", () => {
+ for (const investigation of Object.values(fixtures.demoInvestigations)) {
+ expect(investigation.investigationId.startsWith(DEMO_ID_PREFIX)).toBe(true);
+ for (const hypothesis of investigation.hypotheses) {
+ expect(hypothesis.id.startsWith(DEMO_ID_PREFIX)).toBe(true);
+ }
+ }
+ for (const watch of fixtures.demoWatches.row) {
+ expect(watch.id.startsWith(DEMO_ID_PREFIX)).toBe(true);
+ }
+ for (const prompts of Object.values(fixtures.demoPromptSets)) {
+ for (const prompt of prompts) {
+ expect(prompt.id.startsWith(DEMO_ID_PREFIX)).toBe(true);
+ }
+ }
+ });
+
+ it("marks every resource id, so nothing can pass for a real one", () => {
+ for (const value of Object.values(fixtures.demoViewBlocks)) {
+ if (value.type === "diagnosis") {
+ expect(value.runId).toContain(DEMO_MARKER);
+ }
+ }
+ for (const id of Object.values({
+ failedRunId: fixtures.demoInvestigationConcluded.runId,
+ slowRunId: fixtures.demoInvestigationInconclusive.runId,
+ })) {
+ expect(id).toContain(DEMO_MARKER);
+ }
+ });
+
+ it("rejects a zero source line instead of dropping it", () => {
+ expect(() => demoSourceUri("abc", "src/a.ts", 0)).toThrow(/positive integer/);
+ expect(demoSourceUri("abc", "src/a.ts", 42)).toContain("?line=42");
+ expect(demoSourceUri("abc", "src/a.ts")).not.toContain("line=");
+ });
+});
+
+describe("view block fixtures", () => {
+ const blocks = Object.values(fixtures.demoViewBlocks);
+
+ it("parses every block through the lenient stored-block schema", () => {
+ for (const block of blocks) {
+ const result = safeParseStoredViewBlock(block);
+ expect(result.success, JSON.stringify(result.error?.issues)).toBe(true);
+ }
+ });
+
+ it("parses the enveloped blocks through the strict schema too", () => {
+ for (const block of [
+ fixtures.demoDiagnosisBlockFirstPass,
+ fixtures.demoDiagnosisBlockRevised,
+ fixtures.demoChartBlock,
+ ]) {
+ expect(viewBlockSchema.safeParse(block).success).toBe(true);
+ expect(isRevisableBlock(block)).toBe(true);
+ }
+ });
+
+ it("keeps one legacy, envelope-less block that is not revisable", () => {
+ const legacy = fixtures.demoLegacyDiagnosisBlock;
+ expect(viewBlockSchema.safeParse(legacy).success).toBe(false);
+ expect(safeParseStoredViewBlock(legacy).success).toBe(true);
+ expect(isRevisableBlock(legacy)).toBe(false);
+ });
+
+ it("revises a block by id rather than emitting a second one", () => {
+ expect(fixtures.demoDiagnosisBlockRevised.id).toBe(fixtures.demoDiagnosisBlockFirstPass.id);
+ expect(fixtures.demoDiagnosisBlockRevised.revision).toBeGreaterThan(
+ fixtures.demoDiagnosisBlockFirstPass.revision
+ );
+ });
+});
+
+describe("investigation fixtures", () => {
+ const investigations = Object.values(fixtures.demoInvestigations);
+
+ const allEvidence = (): Evidence[] =>
+ investigations.flatMap((investigation) => [
+ ...investigation.evidence,
+ ...investigation.hypotheses.flatMap((hypothesis) => hypothesis.evidence),
+ ]);
+
+ it("cites only valid trigger:// URIs, with the kind matching the URI", () => {
+ for (const evidence of allEvidence()) {
+ const parsed = safeParseTriggerUri(evidence.uri);
+ expect(parsed.success, `${evidence.uri}: ${!parsed.success ? parsed.error : ""}`).toBe(true);
+ if (parsed.success) expect(parsed.data.kind).toBe(evidence.kind);
+ expect(evidence.uri).toContain(DEMO_MARKER);
+ }
+ });
+
+ it("only offers a fix when it concluded, and only 'check next' when it didn't", () => {
+ for (const investigation of investigations) {
+ if (investigation.outcome === "concluded") {
+ expect(investigation.remediation).toBeTruthy();
+ expect(investigation.checkNext).toBeUndefined();
+ } else {
+ expect(investigation.remediation).toBeUndefined();
+ }
+ if (investigation.outcome === "inconclusive") {
+ expect(investigation.checkNext?.length).toBeGreaterThan(0);
+ }
+ }
+ });
+
+ it("gives the concluded card at least two settled hypotheses", () => {
+ const settled = fixtures.demoInvestigationConcluded.hypotheses.filter(
+ (hypothesis) => hypothesis.verdict !== "testing"
+ );
+ expect(settled.length).toBeGreaterThanOrEqual(2);
+ expect(settled.some((h) => h.verdict === "validated")).toBe(true);
+ expect(settled.some((h) => h.verdict === "invalidated")).toBe(true);
+ expect(
+ fixtures.demoInvestigationConcluded.hypotheses.every(
+ (h) => h.verdict === "testing" || h.finding
+ )
+ ).toBe(true);
+ });
+
+ it("keeps a streaming revision with a hypothesis still testing", () => {
+ expect(fixtures.demoInvestigationStreamingRev1.investigationId).toBe(
+ fixtures.demoInvestigationStreamingRev0.investigationId
+ );
+ expect(fixtures.demoInvestigationStreamingRev1.revision).toBeGreaterThan(
+ fixtures.demoInvestigationStreamingRev0.revision
+ );
+ expect(
+ fixtures.demoInvestigationStreamingRev1.hypotheses.some((h) => h.verdict === "testing")
+ ).toBe(true);
+ });
+
+ it("hedges the dirty-commit variant with the agreed wording", () => {
+ expect(fixtures.demoInvestigationDirtyCommit.caveat?.kind).toBe("dirty_commit");
+ expect(fixtures.demoInvestigationDirtyCommit.caveat?.message).toContain(
+ "nearest repository snapshot"
+ );
+ });
+
+ it("cites file:line@sha in the show-code turn", () => {
+ expect(fixtures.demoShowCodeMarkdown).toMatch(/\.ts:\d+(-\d+)?@[0-9a-z]{7}/);
+ expect(fixtures.demoShowCodeMarkdown).toContain("```diff");
+ });
+});
+
+describe("watch fixtures", () => {
+ it("validates every spec against the contracts schema", () => {
+ for (const watch of fixtures.demoWatches.row) {
+ const result = watchSpecSchema.safeParse(watch.spec);
+ expect(result.success, JSON.stringify(result.error?.issues)).toBe(true);
+ }
+ });
+
+ it("derives the chip identity from the spec", () => {
+ for (const watch of fixtures.demoWatches.row) {
+ expect(watch.identity).toBe(watchIdentity(watch.spec));
+ }
+ });
+
+ it("covers every watch status and offers cancel only while active", () => {
+ const statuses = new Set(fixtures.demoWatches.row.map((watch) => watch.status));
+ expect(statuses).toEqual(new Set(["active", "fired", "expired", "cancelled"]));
+ for (const watch of fixtures.demoWatches.row) {
+ expect(watch.cancellable).toBe(watch.status === "active");
+ }
+ });
+
+ it("has an expiry narration that admits it could not verify", () => {
+ expect(fixtures.demoWatchNarration.expiryUnverified).toContain("couldn't verify");
+ });
+});
+
+describe("intent fixtures", () => {
+ it("validates every intent and marks propose_fix non-executable", () => {
+ for (const demoIntent of Object.values(fixtures.demoIntents)) {
+ const result = agentIntentSchema.safeParse(demoIntent.intent);
+ expect(result.success, JSON.stringify(result.error?.issues)).toBe(true);
+ expect(demoIntent.executable).toBe(demoIntent.intent.kind !== "propose_fix");
+ }
+ });
+
+ it("points the filtered-runs example at the runs collection, not one run", () => {
+ const target = fixtures.demoIntents.navigateToFailedRuns.intent;
+ expect(target.kind).toBe("navigate");
+ if (target.kind !== "navigate") return;
+ const parsed = safeParseTriggerUri(target.target);
+ expect(parsed.success).toBe(true);
+ if (parsed.success) expect(parsed.data.kind).toBe("runs");
+ });
+});
+
+describe("page context and prompt fixtures", () => {
+ it("validates every page context", () => {
+ for (const context of Object.values(fixtures.demoPageContexts)) {
+ const result = agentPageContextSchema.safeParse(context);
+ expect(result.success, JSON.stringify(result.error?.issues)).toBe(true);
+ }
+ });
+
+ it("covers all four signal kinds", () => {
+ const kinds = new Set(fixtures.demoSignalsByPriority.map((signal) => signal.kind));
+ expect(kinds).toEqual(
+ new Set(["fresh_failure", "waiting_run", "slow_run", "concurrency_saturation"])
+ );
+ });
+
+ it("validates every chip, stays under the cap, and promotes at most one", () => {
+ for (const prompts of Object.values(fixtures.demoPromptSets)) {
+ expect(prompts.length).toBeLessThanOrEqual(SUGGESTED_PROMPT_CAP);
+ expect(prompts.filter((prompt) => prompt.source === "promoted").length).toBeLessThanOrEqual(
+ 1
+ );
+ for (const prompt of prompts) {
+ expect(suggestedPromptSchema.safeParse(prompt).success).toBe(true);
+ }
+ }
+ });
+
+ it("drops dismissed chips from the resolved row", () => {
+ for (const id of fixtures.demoDismissedPromptIds) {
+ expect(fixtures.demoPromptsAfterDismissal.some((prompt) => prompt.id === id)).toBe(false);
+ }
+ });
+
+ it("dismisses a chip the resolver actually emits", () => {
+ const full = resolveSuggestedPrompts(fixtures.demoFailedRunPageContext);
+ const after = resolveSuggestedPrompts(fixtures.demoFailedRunPageContext, {
+ dismissedIds: fixtures.demoResolvedDismissedPromptIds,
+ });
+ expect(full.map((prompt) => prompt.id)).toContain(fixtures.demoResolvedDismissedPromptIds[0]);
+ expect(after.map((prompt) => prompt.id)).not.toEqual(full.map((prompt) => prompt.id));
+ });
+});
+
+describe("report fixtures", () => {
+ it("covers a healthy and a degraded verdict", () => {
+ expect(fixtures.demoHealthyReport.summary.severity).toBe("ok");
+ expect(fixtures.demoDegradedReport.summary.severity).toBe("crit");
+ });
+
+ it("references only metrics the report carries, and only links it declares", () => {
+ for (const vm of Object.values(fixtures.demoReports)) {
+ const metricIds = new Set(vm.metrics.map((metric) => metric.id));
+ for (const finding of vm.findings) {
+ for (const id of finding.metricIds) expect(metricIds.has(id), id).toBe(true);
+ }
+ const linkKeys = new Set(vm.links.map((link) => link.key));
+ for (const entry of vm.footer) {
+ if (entry.link) expect(linkKeys.has(entry.link), entry.link).toBe(true);
+ }
+ expect(vm.footer.length).toBeLessThanOrEqual(3);
+ }
+ });
+});
+
+describe("chart fixtures", () => {
+ it("has a row for every configured column", () => {
+ const columns = fixtures.demoChart.columns.map((column) => column.name);
+ for (const row of fixtures.demoChart.rows) {
+ expect(Object.keys(row).sort()).toEqual([...columns].sort());
+ }
+ expect(columns).toContain(fixtures.demoChart.config.xAxisColumn);
+ for (const y of fixtures.demoChart.config.yAxisColumns) expect(columns).toContain(y);
+ });
+});
+
+describe("isolation", () => {
+ it("reads every form an import can take, including the ones that bind nothing", () => {
+ const source = [
+ `import { a } from "./a";`,
+ `import "~/db.server";`,
+ `import type { B } from "./b";`,
+ `export * from "./c";`,
+ `const d = await import("~/routes/thing");`,
+ `import("./lazy").then((m) => m.go());`,
+ ].join("\n");
+
+ expect(importSpecifiers(source).sort()).toEqual([
+ "./a",
+ "./b",
+ "./c",
+ "./lazy",
+ "~/db.server",
+ "~/routes/thing",
+ ]);
+ });
+
+ it("imports no server module and no route", () => {
+ for (const path of sourceFiles) {
+ const specifiers = importSpecifiers(readFileSync(path, "utf8"));
+ for (const specifier of specifiers) {
+ expect(specifier.includes(".server"), `${path} -> ${specifier}`).toBe(false);
+ expect(/routes?\//.test(specifier), `${path} -> ${specifier}`).toBe(false);
+ expect(specifier.includes("~/db"), `${path} -> ${specifier}`).toBe(false);
+ }
+ }
+ });
+
+ it("makes no network calls", () => {
+ for (const path of sourceFiles) {
+ const source = readFileSync(path, "utf8");
+ expect(/\bfetch\s*\(/.test(source), path).toBe(false);
+ expect(/\buseFetcher\b/.test(source), path).toBe(false);
+ }
+ });
+
+ it("has no server file of its own", () => {
+ expect(sourceFiles.filter((path) => path.endsWith(".server.ts"))).toEqual([]);
+ });
+});
diff --git a/apps/webapp/app/components/dashboard-agent/demo/fixtures/blocks.ts b/apps/webapp/app/components/dashboard-agent/demo/fixtures/blocks.ts
new file mode 100644
index 0000000000..2b5c7c5db8
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/fixtures/blocks.ts
@@ -0,0 +1,126 @@
+import {
+ VIEW_BLOCK_VERSION,
+ type EnvelopedChartBlock,
+ type EnvelopedDiagnosisBlock,
+ type ViewBlock,
+} from "@internal/dashboard-agent-contracts";
+import { demoId, demoRunsUri, DEMO_WORLD } from "../ids";
+
+const envelope = (id: string, revision = 0) => ({
+ id: demoId(id),
+ revision,
+ version: VIEW_BLOCK_VERSION,
+});
+
+export const demoDiagnosisBlockFirstPass: EnvelopedDiagnosisBlock = {
+ ...envelope("diagnosis-order-receipt", 0),
+ type: "diagnosis",
+ runId: DEMO_WORLD.failedRunId,
+ summary: `${DEMO_WORLD.taskId} failed while calling the email provider. The call came back 429 and the run exhausted its 3 retries.`,
+ category: "rate_limit",
+ likelyCause:
+ "The email provider is rate limiting this API key. All three attempts landed inside the same 20-second window, so the retries never had a chance to clear the limit.",
+ confidence: "medium",
+ evidence: [
+ {
+ type: "error",
+ detail: "ProviderError: 429 Too Many Requests (rate_limit_exceeded)",
+ reference: DEMO_WORLD.failedRunId,
+ },
+ {
+ type: "failed_span",
+ detail: "sendEmail span failed after 412ms on attempt 3 of 3",
+ reference: DEMO_WORLD.failedSpanId,
+ },
+ ],
+ nextSteps: [
+ "Spread the retries out: raise the retry delay so attempts don't land in the same rate-limit window.",
+ "Cap concurrency on the queue so the task can't burst past the provider's per-second limit.",
+ ],
+};
+
+export const demoDiagnosisBlockRevised: EnvelopedDiagnosisBlock = {
+ ...demoDiagnosisBlockFirstPass,
+ ...envelope("diagnosis-order-receipt", 1),
+ summary: `${DEMO_WORLD.taskId} failed because the email provider rate limited it. 41 runs on this queue hit the same 429 in the last hour — this run isn't special.`,
+ confidence: "high",
+ impact: `41 runs of ${DEMO_WORLD.taskId} failed the same way in the last hour, all on the ${DEMO_WORLD.queue} queue.`,
+ evidence: [
+ ...demoDiagnosisBlockFirstPass.evidence,
+ {
+ type: "historical_match",
+ detail: "41 runs failed with the same error fingerprint in the last hour",
+ reference: DEMO_WORLD.errorFingerprint,
+ },
+ {
+ type: "source",
+ detail: "retry.maxAttempts is 3 with a 1s base delay and no jitter",
+ reference: `${DEMO_WORLD.sourcePath}:18`,
+ },
+ ],
+ nextSteps: [
+ "Raise the retry delay (or add jitter) so attempts don't all land inside one rate-limit window.",
+ `Cap concurrency on ${DEMO_WORLD.queue} to stay under the provider's per-second limit.`,
+ "Consider a queue-level rate limit so a backlog can't burst into the provider.",
+ ],
+ actions: [
+ { label: "View run", kind: "view_run", target: DEMO_WORLD.failedRunId },
+ {
+ label: "Read the retries docs",
+ kind: "docs",
+ target: "https://trigger.dev/docs/errors-retrying",
+ },
+ ],
+};
+
+export const demoChartBlock: EnvelopedChartBlock = {
+ ...envelope("chart-failures-by-task", 0),
+ type: "chart",
+ title: "Failed runs per hour, by task",
+ query:
+ "SELECT toStartOfHour(created_at) AS hour, task_identifier, countIf(status = 'COMPLETED_WITH_ERROR') AS failures FROM task_runs GROUP BY hour, task_identifier ORDER BY hour",
+ period: "24h",
+ chartType: "line",
+ xAxisColumn: "hour",
+ yAxisColumns: ["failures"],
+ groupByColumn: "task_identifier",
+ stacked: false,
+ aggregation: "sum",
+ actions: [
+ {
+ label: `Investigate ${DEMO_WORLD.taskId}`,
+ intent: {
+ kind: "ask",
+ prompt: `Investigate the ${DEMO_WORLD.taskId} failures — why are they failing?`,
+ },
+ },
+ {
+ label: "See its failed runs",
+ intent: {
+ kind: "navigate",
+ target: demoRunsUri(),
+ filters: { tasks: [DEMO_WORLD.taskId], statuses: ["COMPLETED_WITH_ERROR"], period: "1d" },
+ },
+ },
+ ],
+};
+
+// No envelope on purpose: the pre-envelope transcript path must still render.
+export const demoLegacyDiagnosisBlock: ViewBlock = {
+ type: "diagnosis",
+ runId: DEMO_WORLD.priorRunId,
+ summary:
+ "This run failed the same way three weeks ago, before the panel stamped identity onto its cards.",
+ category: "rate_limit",
+ likelyCause: "The email provider rate limited the same API key.",
+ confidence: "medium",
+ evidence: [{ type: "error", detail: "ProviderError: 429 Too Many Requests" }],
+ nextSteps: ["Nothing to do — kept as a fixture for the pre-envelope render path."],
+};
+
+export const demoViewBlocks = {
+ diagnosisFirstPass: demoDiagnosisBlockFirstPass,
+ diagnosisRevised: demoDiagnosisBlockRevised,
+ chart: demoChartBlock,
+ legacyDiagnosis: demoLegacyDiagnosisBlock,
+} as const;
diff --git a/apps/webapp/app/components/dashboard-agent/demo/fixtures/chart.ts b/apps/webapp/app/components/dashboard-agent/demo/fixtures/chart.ts
new file mode 100644
index 0000000000..c1a00a2632
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/fixtures/chart.ts
@@ -0,0 +1,50 @@
+import type { OutputColumnMetadata } from "@internal/clickhouse";
+import type { ChartConfiguration } from "~/components/metrics/QueryWidget";
+
+export const demoChartColumns: OutputColumnMetadata[] = [
+ { name: "hour", type: "DateTime" },
+ { name: "task_identifier", type: "String" },
+ { name: "failures", type: "UInt64", format: "quantity" },
+];
+
+const SERIES: Record = {
+ "send-order-receipt": [1, 0, 2, 1, 3, 2, 4, 9, 14, 22, 31, 41],
+ "generate-monthly-report": [0, 1, 0, 0, 1, 0, 2, 1, 0, 1, 2, 1],
+ "sync-crm-contacts": [3, 2, 4, 3, 2, 3, 2, 4, 3, 2, 3, 2],
+};
+
+const START_MS = Date.parse("2026-07-26T23:00:00.000Z");
+const HOUR_MS = 3_600_000;
+
+export const demoChartRows: Record[] = Object.entries(SERIES).flatMap(
+ ([task, points]) =>
+ points.map((failures, i) => ({
+ hour: new Date(START_MS + i * HOUR_MS).toISOString(),
+ task_identifier: task,
+ failures,
+ }))
+);
+
+export const demoChartConfig: ChartConfiguration = {
+ chartType: "line",
+ xAxisColumn: "hour",
+ yAxisColumns: ["failures"],
+ groupByColumn: "task_identifier",
+ stacked: false,
+ sortByColumn: null,
+ sortDirection: "desc",
+ aggregation: "sum",
+};
+
+export const demoChartTimeRange = {
+ from: new Date(START_MS).toISOString(),
+ to: new Date(START_MS + 11 * HOUR_MS).toISOString(),
+};
+
+export const demoChart = {
+ rows: demoChartRows,
+ columns: demoChartColumns,
+ config: demoChartConfig,
+ timeRange: demoChartTimeRange,
+ title: "Failed runs per hour, by task",
+} as const;
diff --git a/apps/webapp/app/components/dashboard-agent/demo/fixtures/index.ts b/apps/webapp/app/components/dashboard-agent/demo/fixtures/index.ts
new file mode 100644
index 0000000000..15a2f1be72
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/fixtures/index.ts
@@ -0,0 +1,8 @@
+export * from "./blocks";
+export * from "./chart";
+export * from "./intents";
+export * from "./investigation";
+export * from "./messages";
+export * from "./page-context";
+export * from "./reports";
+export * from "./watches";
diff --git a/apps/webapp/app/components/dashboard-agent/demo/fixtures/intents.ts b/apps/webapp/app/components/dashboard-agent/demo/fixtures/intents.ts
new file mode 100644
index 0000000000..3fea9f2095
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/fixtures/intents.ts
@@ -0,0 +1,60 @@
+import { isExecutableIntent, type AgentIntent } from "@internal/dashboard-agent-contracts";
+import { DEMO_WORLD, demoRunUri, demoRunsUri } from "../ids";
+import { demoBacklogDrainWatch } from "./watches";
+
+export type DemoIntent = {
+ intent: AgentIntent;
+ outcome: string;
+ deepLinkLabel?: string;
+ executable: boolean;
+};
+
+const demoIntent = (intent: AgentIntent, outcome: string, deepLinkLabel?: string): DemoIntent => ({
+ intent,
+ outcome,
+ deepLinkLabel,
+ executable: isExecutableIntent(intent),
+});
+
+export const demoNavigateToFailedRuns = demoIntent(
+ {
+ kind: "navigate",
+ target: demoRunsUri(),
+ filters: {
+ statuses: ["COMPLETED_WITH_ERROR"],
+ period: "24h",
+ tasks: [DEMO_WORLD.taskId],
+ },
+ },
+ "Opened runs filtered to failed · last 24h · send-order-receipt",
+ "/runs?statuses=COMPLETED_WITH_ERROR&period=24h&tasks=send-order-receipt"
+);
+
+export const demoNavigateToRun = demoIntent(
+ { kind: "navigate", target: demoRunUri(DEMO_WORLD.failedRunId) },
+ `Opened ${DEMO_WORLD.failedRunId}`,
+ `/runs/${DEMO_WORLD.failedRunId}`
+);
+
+export const demoAskIntent = demoIntent(
+ { kind: "ask", prompt: "Do you want me to watch the retry and tell you when it finishes?" },
+ "Asked a follow-up"
+);
+
+export const demoWatchIntent = demoIntent(
+ { kind: "watch", spec: demoBacklogDrainWatch.spec },
+ `Watching ${DEMO_WORLD.backlogQueue} · checking every 5 min for up to 6h`
+);
+
+export const demoProposeFixIntent = demoIntent(
+ { kind: "propose_fix", investigationId: "demo:investigation-order-receipt" },
+ "Rejected: proposing a fix isn't available yet"
+);
+
+export const demoIntents = {
+ navigateToFailedRuns: demoNavigateToFailedRuns,
+ navigateToRun: demoNavigateToRun,
+ ask: demoAskIntent,
+ watch: demoWatchIntent,
+ proposeFix: demoProposeFixIntent,
+} as const;
diff --git a/apps/webapp/app/components/dashboard-agent/demo/fixtures/investigation.ts b/apps/webapp/app/components/dashboard-agent/demo/fixtures/investigation.ts
new file mode 100644
index 0000000000..8b3c250633
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/fixtures/investigation.ts
@@ -0,0 +1,438 @@
+// Block `id` is the `investigationId` and `revision` climbs. The contracts package freezes that.
+import type { Evidence } from "@internal/dashboard-agent-contracts";
+import {
+ DEMO_WORLD,
+ demoDeploymentUri,
+ demoErrorUri,
+ demoId,
+ demoQueueUri,
+ demoRunUri,
+ demoSourceUri,
+ demoSpanUri,
+} from "../ids";
+
+export type DemoHypothesisVerdict = "testing" | "validated" | "invalidated";
+
+export type DemoHypothesis = {
+ id: string;
+ statement: string;
+ verdict: DemoHypothesisVerdict;
+ finding?: string;
+ evidence: Evidence[];
+};
+
+export type DemoInvestigationOutcome = "in_progress" | "concluded" | "inconclusive";
+
+export type DemoInvestigationSeverity = "info" | "warn" | "crit";
+
+export type DemoInvestigationCaveat = {
+ kind: "dirty_commit";
+ message: string;
+};
+
+export type DemoInvestigation = {
+ investigationId: string;
+ revision: number;
+ outcome: DemoInvestigationOutcome;
+ severity: DemoInvestigationSeverity;
+ confidence: "high" | "medium" | "low";
+ runId?: string;
+ title: string;
+ headline: string;
+ remediation?: string;
+ checkNext?: string[];
+ progress?: string;
+ hypotheses: DemoHypothesis[];
+ evidence: Evidence[];
+ caveat?: DemoInvestigationCaveat;
+ startedAt: string;
+ updatedAt: string;
+};
+
+const runUri = demoRunUri(DEMO_WORLD.failedRunId);
+const spanUri = demoSpanUri(DEMO_WORLD.failedRunId, DEMO_WORLD.failedSpanId);
+const errorUri = demoErrorUri(DEMO_WORLD.errorFingerprint);
+const queueUri = demoQueueUri(DEMO_WORLD.queue);
+const sourceUri = demoSourceUri(DEMO_WORLD.sourceSha, DEMO_WORLD.sourcePath, 18);
+
+const INVESTIGATION_ID = demoId("investigation-order-receipt");
+
+const errorEvidence: Evidence = {
+ kind: "error",
+ uri: errorUri,
+ label: "rate_limit_exceeded · 41 runs in the last hour",
+ excerpt: "ProviderError: 429 Too Many Requests (rate_limit_exceeded)",
+};
+
+const spanEvidence: Evidence = {
+ kind: "span",
+ uri: spanUri,
+ label: "sendEmail span, attempt 3 of 3",
+ excerpt: "sendEmail 412ms ✕ 429 Too Many Requests",
+};
+
+const sourceEvidence: Evidence = {
+ kind: "source",
+ uri: sourceUri,
+ label: `${DEMO_WORLD.sourcePath}:18`,
+ excerpt: "retry: { maxAttempts: 3, minTimeoutInMs: 1_000, factor: 1 },",
+};
+
+const queueEvidence: Evidence = {
+ kind: "queue",
+ uri: queueUri,
+ label: `${DEMO_WORLD.queue} · concurrency 50 of 50`,
+ excerpt: "concurrency pinned at 50 for 38 of the last 60 min",
+};
+
+const runEvidence: Evidence = {
+ kind: "run",
+ uri: runUri,
+ label: `${DEMO_WORLD.failedRunId} · failed after 3 attempts`,
+ excerpt: "attempt 1 429 · attempt 2 429 · attempt 3 429 — all within 19.4s",
+};
+
+const priorRunEvidence: Evidence = {
+ kind: "run",
+ uri: demoRunUri(DEMO_WORLD.priorRunId),
+ label: `${DEMO_WORLD.priorRunId} · same payload, completed in 1.2s`,
+ excerpt: "2,104 runs with this payload shape succeeded earlier today",
+};
+
+const deploymentEvidence: Evidence = {
+ kind: "deployment",
+ uri: demoDeploymentUri(DEMO_WORLD.deploymentVersion),
+ label: `${DEMO_WORLD.deploymentVersion} · deployed 19h before the first failure`,
+ excerpt: "first failure 09:02, deploy 14:11 the previous day — no overlap",
+};
+
+export const demoInvestigationStreamingRev0: DemoInvestigation = {
+ investigationId: INVESTIGATION_ID,
+ revision: 0,
+ outcome: "in_progress",
+ severity: "warn",
+ confidence: "low",
+ runId: DEMO_WORLD.failedRunId,
+ title: `Why is ${DEMO_WORLD.taskId} failing?`,
+ headline:
+ "All three attempts of this run ended in an error from the email provider. I'm reading the spans to see which call failed and whether the retries had a chance to succeed.",
+ progress: "Reading the run's spans",
+ hypotheses: [
+ {
+ id: demoId("hyp-rate-limit"),
+ statement: "The email provider is rate limiting this API key.",
+ verdict: "testing",
+ evidence: [],
+ },
+ {
+ id: demoId("hyp-bad-payload"),
+ statement: "The payload is malformed and the provider rejects it.",
+ verdict: "testing",
+ evidence: [],
+ },
+ {
+ id: demoId("hyp-retry-window"),
+ statement: "The retry schedule keeps every attempt inside one rate-limit window.",
+ verdict: "testing",
+ evidence: [],
+ },
+ ],
+ evidence: [runEvidence, spanEvidence],
+ startedAt: "2026-07-27T10:14:02.000Z",
+ updatedAt: "2026-07-27T10:14:06.000Z",
+};
+
+export const demoInvestigationEarly: DemoInvestigation = {
+ investigationId: demoId("investigation-order-receipt-early"),
+ revision: 0,
+ outcome: "in_progress",
+ severity: "warn",
+ confidence: "low",
+ runId: DEMO_WORLD.failedRunId,
+ title: `Why is ${DEMO_WORLD.taskId} failing?`,
+ headline:
+ "The run failed after three attempts. I'm reading its spans to see which call failed before I put any hypotheses up.",
+ progress: "Reading the run's spans",
+ hypotheses: [],
+ evidence: [runEvidence],
+ startedAt: "2026-07-27T10:14:02.000Z",
+ updatedAt: "2026-07-27T10:14:03.000Z",
+};
+
+export const demoInvestigationStreamingRev1: DemoInvestigation = {
+ ...demoInvestigationStreamingRev0,
+ revision: 1,
+ confidence: "medium",
+ headline:
+ "Every attempt came back 429 rate_limit_exceeded, and 41 other runs of this task hit the same error in the last hour. Checking whether the retry schedule made it worse.",
+ progress: "Comparing against the last hour of runs on this queue",
+ hypotheses: [
+ {
+ ...demoInvestigationStreamingRev0.hypotheses[0]!,
+ verdict: "validated",
+ finding: "All three attempts returned 429 rate_limit_exceeded inside a 20-second window.",
+ evidence: [errorEvidence, spanEvidence],
+ },
+ {
+ ...demoInvestigationStreamingRev0.hypotheses[1]!,
+ verdict: "invalidated",
+ finding:
+ "The same payload shape succeeded on 2,104 runs earlier today, and the provider never returned a 4xx other than 429.",
+ evidence: [priorRunEvidence],
+ },
+ {
+ ...demoInvestigationStreamingRev0.hypotheses[2]!,
+ verdict: "testing",
+ evidence: [queueEvidence],
+ },
+ ],
+ evidence: [runEvidence, errorEvidence, queueEvidence],
+ updatedAt: "2026-07-27T10:14:11.000Z",
+};
+
+export const demoInvestigationConcluded: DemoInvestigation = {
+ investigationId: INVESTIGATION_ID,
+ revision: 2,
+ outcome: "concluded",
+ severity: "crit",
+ confidence: "high",
+ runId: DEMO_WORLD.failedRunId,
+ title: `${DEMO_WORLD.taskId} is failing on every retry`,
+ headline:
+ "The email provider is rate limiting this API key, and the task's retries all land inside the same limit window — so every attempt fails. 41 runs failed this way in the last hour.",
+ remediation:
+ "Spread the attempts out and stop the queue bursting into the provider: raise `minTimeoutInMs` to 30s with a factor of 2 (or add jitter) so the three attempts span the limit window instead of sharing it, and cap the queue's concurrency at 20 to stay under the provider's per-second ceiling. Neither change needs a code deploy if you set the queue limit from the dashboard.",
+ hypotheses: [
+ {
+ id: demoId("hyp-rate-limit"),
+ statement: "The email provider is rate limiting this API key.",
+ verdict: "validated",
+ finding:
+ "All three attempts returned 429 rate_limit_exceeded, and 41 other runs hit the same fingerprint in the last hour.",
+ evidence: [errorEvidence, spanEvidence],
+ },
+ {
+ id: demoId("hyp-bad-payload"),
+ statement: "The payload is malformed and the provider rejects it.",
+ verdict: "invalidated",
+ finding:
+ "The same payload succeeded on 2,104 runs earlier today; the provider never returned a 4xx other than 429.",
+ evidence: [priorRunEvidence, runEvidence],
+ },
+ {
+ id: demoId("hyp-retry-window"),
+ statement: "The retry schedule keeps every attempt inside one rate-limit window.",
+ verdict: "validated",
+ finding:
+ "maxAttempts 3 with a 1s base delay and factor 1 puts all three attempts inside 20 seconds.",
+ evidence: [sourceEvidence, spanEvidence],
+ },
+ {
+ id: demoId("hyp-queue-burst"),
+ statement: "The queue is bursting into the provider faster than its per-second ceiling.",
+ verdict: "validated",
+ finding:
+ "The queue sat at its concurrency limit of 50 for 38 of the last 60 minutes, so ~50 sends land on the provider at once every time it drains.",
+ evidence: [queueEvidence],
+ },
+ {
+ id: demoId("hyp-deploy-regression"),
+ statement: "Yesterday's deploy introduced the failure.",
+ verdict: "invalidated",
+ finding:
+ "The deploy went out 19 hours before the first failure and the task ran clean for most of that window, so the timing rules it out.",
+ evidence: [deploymentEvidence],
+ },
+ ],
+ evidence: [errorEvidence, spanEvidence, sourceEvidence, queueEvidence, deploymentEvidence],
+ startedAt: "2026-07-27T10:14:02.000Z",
+ updatedAt: "2026-07-27T10:14:24.000Z",
+};
+
+export const demoInvestigationConcludedNoCode: DemoInvestigation = {
+ investigationId: demoId("investigation-queue-saturation"),
+ revision: 2,
+ outcome: "concluded",
+ severity: "crit",
+ confidence: "high",
+ title: `${DEMO_WORLD.queue} is starving — nothing is starting`,
+ headline: `The ${DEMO_WORLD.queue} queue has sat at its concurrency limit of 50 for 38 of the last 60 minutes, so new runs wait behind the ones already running. The p95 wait is 2 minutes against a p50 of 38 seconds, and every run that does start finishes normally.`,
+ remediation:
+ "Raise the queue's concurrency limit (or the environment's, if that's the one it's hitting) until the depth trend flattens. You can set it from the queue page — no deploy needed. If the limit is deliberate, the backlog is telling you the arrival rate now exceeds it, and the trigger side is what has to change.",
+ hypotheses: [
+ {
+ id: demoId("hyp-queue-limit"),
+ statement: "Runs are waiting on the queue's concurrency limit, not failing.",
+ verdict: "validated",
+ finding:
+ "The queue was pinned at 50 of 50 for 38 of the last 60 minutes while the depth climbed from 10 to 4,210, and no run in the window failed.",
+ evidence: [queueEvidence],
+ },
+ {
+ id: demoId("hyp-queue-slow-task"),
+ statement: "The task itself got slower, so each slot is held longer.",
+ verdict: "invalidated",
+ finding:
+ "Runs that did start completed in ~1.2s, the same as earlier today — the slots turn over as fast as they ever did.",
+ evidence: [priorRunEvidence],
+ },
+ ],
+ evidence: [queueEvidence, priorRunEvidence],
+ startedAt: "2026-07-27T11:02:00.000Z",
+ updatedAt: "2026-07-27T11:02:19.000Z",
+};
+
+export const demoInvestigationInconclusive: DemoInvestigation = {
+ investigationId: demoId("investigation-monthly-report"),
+ revision: 1,
+ outcome: "inconclusive",
+ severity: "warn",
+ confidence: "low",
+ runId: DEMO_WORLD.slowRunId,
+ title: `Why is ${DEMO_WORLD.slowTaskId} slow?`,
+ headline:
+ "This run has been executing for 24 minutes against a p95 of 3 minutes, and the time is spent inside one un-instrumented span. I can see where it stalls but not why — nothing in the telemetry explains it.",
+ checkNext: [
+ "Add a span (or a log) around the report aggregation step so the stall shows up in the trace.",
+ "Check the warehouse the aggregation reads from — a slow upstream query would look exactly like this.",
+ "Compare against the last run that finished normally to see whether the payload got bigger.",
+ ],
+ hypotheses: [
+ {
+ id: demoId("hyp-slow-oom"),
+ statement: "The run is thrashing against its memory limit.",
+ verdict: "invalidated",
+ finding:
+ "Peak memory stayed at 38% of the machine's limit for the whole run, and there is no OOM signal on the attempt.",
+ evidence: [
+ {
+ kind: "run",
+ uri: demoRunUri(DEMO_WORLD.slowRunId),
+ label: `${DEMO_WORLD.slowRunId} · machine metrics, large-1x`,
+ excerpt: "memory peak 38% · cpu 11% avg · no restarts",
+ },
+ ],
+ },
+ {
+ id: demoId("hyp-slow-queue-wait"),
+ statement: "The run spent the time waiting for a worker rather than executing.",
+ verdict: "invalidated",
+ finding:
+ "It was dequeued 40ms after it was triggered and has been executing ever since — the time is inside the attempt, not in front of it.",
+ evidence: [
+ {
+ kind: "queue",
+ uri: demoQueueUri(DEMO_WORLD.backlogQueue),
+ label: `${DEMO_WORLD.backlogQueue} · 3 of 20 concurrency in use`,
+ excerpt: "dequeued 40ms after trigger · no queue wait",
+ },
+ ],
+ },
+ {
+ id: demoId("hyp-slow-upstream"),
+ statement: "An upstream call inside the aggregation step is blocking.",
+ verdict: "testing",
+ finding: undefined,
+ evidence: [
+ {
+ kind: "span",
+ uri: demoSpanUri(DEMO_WORLD.slowRunId, "span_demoe71f"),
+ label: "aggregate span · 23m 41s, no children",
+ excerpt: "aggregate 23m41s ● (no child spans)",
+ },
+ ],
+ },
+ ],
+ evidence: [
+ {
+ kind: "run",
+ uri: demoRunUri(DEMO_WORLD.slowRunId),
+ label: `${DEMO_WORLD.slowRunId} · executing for 24m, p95 is 3m`,
+ excerpt: "status EXECUTING · attempt 1 · started 09:17:22",
+ },
+ {
+ kind: "span",
+ uri: demoSpanUri(DEMO_WORLD.slowRunId, "span_demoe71f"),
+ label: "aggregate span · 23m 41s, no children",
+ excerpt: "aggregate 23m41s ● (no child spans)",
+ },
+ ],
+ startedAt: "2026-07-27T09:41:00.000Z",
+ updatedAt: "2026-07-27T09:41:38.000Z",
+};
+
+export const demoInvestigationDegraded: DemoInvestigation = {
+ investigationId: demoId("investigation-order-receipt-degraded"),
+ revision: 1,
+ outcome: "inconclusive",
+ severity: "warn",
+ confidence: "low",
+ runId: DEMO_WORLD.failedRunId,
+ title: `Why is ${DEMO_WORLD.taskId} failing?`,
+ headline: `Every attempt of this run ended in a 429 from the email provider, and 41 other runs hit the same error in the last hour. I couldn't read the trace — the spans for this run are no longer retained — so I can't tell whether the retries all landed inside one rate-limit window, which is what would explain it.`,
+ checkNext: [
+ "Re-run the investigation on a fresher failure, while its spans are still retained.",
+ "Check the provider's dashboard for the rate limit on this API key and when it resets.",
+ "Compare the task's retry settings against that window — three attempts inside one window would fail as a group.",
+ ],
+ hypotheses: [
+ {
+ id: demoId("hyp-rate-limit"),
+ statement: "The email provider is rate limiting this API key.",
+ verdict: "validated",
+ finding: "All three attempts returned 429 rate_limit_exceeded on the same fingerprint.",
+ evidence: [errorEvidence],
+ },
+ {
+ id: demoId("hyp-retry-window"),
+ statement: "The retry schedule keeps every attempt inside one rate-limit window.",
+ verdict: "testing",
+ finding: "The run's spans are no longer retained, so the attempt timings can't be read.",
+ evidence: [],
+ },
+ ],
+ evidence: [runEvidence, errorEvidence],
+ startedAt: "2026-07-27T10:31:00.000Z",
+ updatedAt: "2026-07-27T10:31:14.000Z",
+};
+
+export const demoInvestigationDirtyCommit: DemoInvestigation = {
+ ...demoInvestigationConcluded,
+ investigationId: demoId("investigation-order-receipt-dirty"),
+ confidence: "medium",
+ caveat: {
+ kind: "dirty_commit",
+ message:
+ "Source lines below come from the nearest repository snapshot, not the exact deployed code — this deploy was built from a working tree with uncommitted changes. The run, span and error evidence is unaffected.",
+ },
+};
+
+export const demoInvestigations = {
+ early: demoInvestigationEarly,
+ streamingRev0: demoInvestigationStreamingRev0,
+ streamingRev1: demoInvestigationStreamingRev1,
+ concluded: demoInvestigationConcluded,
+ concludedNoCode: demoInvestigationConcludedNoCode,
+ inconclusive: demoInvestigationInconclusive,
+ degraded: demoInvestigationDegraded,
+ dirtyCommit: demoInvestigationDirtyCommit,
+} as const;
+
+export const demoShowCodeMarkdown = `Here's the change, against \`${DEMO_WORLD.sourcePath}:14-20@${DEMO_WORLD.sourceSha.slice(0, 7)}\`:
+
+\`\`\`diff
+--- a/${DEMO_WORLD.sourcePath}
++++ b/${DEMO_WORLD.sourcePath}
+@@ -14,7 +14,8 @@ export const sendOrderReceipt = task({
+ id: "${DEMO_WORLD.taskId}",
+ retry: {
+ maxAttempts: 3,
+- minTimeoutInMs: 1_000,
+- factor: 1,
++ minTimeoutInMs: 30_000,
++ factor: 2,
++ randomize: true,
+ },
+\`\`\`
+
+That spreads the three attempts across ~2 minutes instead of 20 seconds. I haven't applied anything — this is the patch I'd suggest.`;
diff --git a/apps/webapp/app/components/dashboard-agent/demo/fixtures/messages.ts b/apps/webapp/app/components/dashboard-agent/demo/fixtures/messages.ts
new file mode 100644
index 0000000000..8cfc119170
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/fixtures/messages.ts
@@ -0,0 +1,71 @@
+import type { UIMessage } from "@ai-sdk/react";
+import type { ViewBlock } from "@internal/dashboard-agent-contracts";
+import { demoId } from "../ids";
+
+type Part = UIMessage["parts"][number];
+
+export function demoMessageId(name: string): string {
+ return demoId(`msg-${name}`);
+}
+
+export function userMessage(name: string, text: string): UIMessage {
+ return { id: demoMessageId(name), role: "user", parts: [{ type: "text", text }] };
+}
+
+export function assistantMessage(name: string, parts: Part[]): UIMessage {
+ return { id: demoMessageId(name), role: "assistant", parts };
+}
+
+export function textPart(text: string): Part {
+ return { type: "text", text, state: "done" };
+}
+
+export function streamingTextPart(text: string): Part {
+ return { type: "text", text, state: "streaming" };
+}
+
+export function reasoningPart(text: string): Part {
+ return { type: "reasoning", text, state: "done" };
+}
+
+export function toolPart(name: string, input: unknown, output: unknown, callName?: string): Part {
+ return {
+ type: `tool-${name}`,
+ toolCallId: demoId(`call-${callName ?? name}`),
+ state: "output-available",
+ input,
+ output,
+ } as Part;
+}
+
+export function pendingToolPart(name: string, input: unknown, callName?: string): Part {
+ return {
+ type: `tool-${name}`,
+ toolCallId: demoId(`call-${callName ?? name}`),
+ state: "input-available",
+ input,
+ } as Part;
+}
+
+export function failedToolPart(
+ name: string,
+ input: unknown,
+ errorText: string,
+ callName?: string
+): Part {
+ return {
+ type: `tool-${name}`,
+ toolCallId: demoId(`call-${callName ?? name}`),
+ state: "output-error",
+ input,
+ errorText,
+ } as Part;
+}
+
+export function renderViewPart(blocks: ViewBlock[], callName?: string): Part {
+ return toolPart("render_view", { blocks }, { blocks }, callName ?? "render-view");
+}
+
+export function sourceUrlPart(url: string, title: string): Part {
+ return { type: "source-url", sourceId: demoId(`source-${title}`), url, title } as Part;
+}
diff --git a/apps/webapp/app/components/dashboard-agent/demo/fixtures/page-context.ts b/apps/webapp/app/components/dashboard-agent/demo/fixtures/page-context.ts
index 2cae37107b..14f58b6169 100644
--- a/apps/webapp/app/components/dashboard-agent/demo/fixtures/page-context.ts
+++ b/apps/webapp/app/components/dashboard-agent/demo/fixtures/page-context.ts
@@ -238,6 +238,12 @@ export const demoPromptSets: Record = {
export const demoDismissedPromptIds: string[] = [demoId("prompt-watch-retry")];
+/**
+ * Ids the resolver itself emits, for dismissing against a live resolve. Dismissing the
+ * fresh-failure chip on `demoFailedRunPageContext` falls back to `sp:run-investigate`.
+ */
+export const demoResolvedDismissedPromptIds: string[] = ["sp:fresh-failure"];
+
export const demoPromptsAfterDismissal: SuggestedPrompt[] = demoPromptSets.failedRun
.filter((p) => !demoDismissedPromptIds.includes(p.id))
.slice(0, SUGGESTED_PROMPT_CAP);
diff --git a/apps/webapp/app/components/dashboard-agent/demo/fixtures/watches.ts b/apps/webapp/app/components/dashboard-agent/demo/fixtures/watches.ts
new file mode 100644
index 0000000000..1b2367a123
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/fixtures/watches.ts
@@ -0,0 +1,149 @@
+import {
+ watchIdentity,
+ type WatchSpec,
+ type WatchStatus,
+} from "@internal/dashboard-agent-contracts";
+import { DEMO_WORLD, demoId } from "../ids";
+
+export type DemoWatch = {
+ id: string;
+ spec: WatchSpec;
+ status: WatchStatus;
+ identity: string;
+ chipLabel: string;
+ createdAt: string;
+ expiresAt: string;
+ cancellable: boolean;
+};
+
+const watch = (
+ name: string,
+ spec: WatchSpec,
+ chipLabel: string,
+ status: WatchStatus,
+ createdAt: string,
+ expiresAt: string
+): DemoWatch => ({
+ id: demoId(`watch-${name}`),
+ spec,
+ status,
+ identity: watchIdentity(spec),
+ chipLabel,
+ createdAt,
+ expiresAt,
+ cancellable: status === "active",
+});
+
+export const demoRunFinishedWatch = watch(
+ "run-finished",
+ {
+ kind: "run_finished",
+ runId: DEMO_WORLD.failedRunId,
+ note: "Tell me when the retry of send-order-receipt finishes.",
+ maxHours: 2,
+ checkEveryMinutes: 1,
+ },
+ DEMO_WORLD.taskId,
+ "active",
+ "2026-07-27T10:15:10.000Z",
+ "2026-07-27T12:15:10.000Z"
+);
+
+export const demoBacklogDrainWatch = watch(
+ "backlog-drain",
+ {
+ kind: "backlog_drain",
+ queue: DEMO_WORLD.backlogQueue,
+ note: "Tell me when the backlog on demo-backlog-drain clears.",
+ maxHours: 6,
+ checkEveryMinutes: 5,
+ },
+ "backlog-drain",
+ "active",
+ "2026-07-27T09:02:00.000Z",
+ "2026-07-27T15:02:00.000Z"
+);
+
+export const demoErrorRecurrenceWatch = watch(
+ "email-sends",
+ {
+ kind: "error_recurrence",
+ // The page cites `error_`, the spec keeps the bare form.
+ fingerprint: DEMO_WORLD.errorFingerprint.replace(/^error_/, ""),
+ note: "Tell me if the rate-limit error comes back.",
+ maxHours: 12,
+ checkEveryMinutes: 15,
+ },
+ "email-sends",
+ "fired",
+ "2026-07-26T22:40:00.000Z",
+ "2026-07-27T10:40:00.000Z"
+);
+
+export const demoHealthRecoveryWatch = watch(
+ "health-recovery",
+ {
+ kind: "health_recovery",
+ report: "health",
+ fromSeverity: "crit",
+ note: "Tell me when prod is healthy again.",
+ maxHours: 4,
+ checkEveryMinutes: 15,
+ },
+ "health-recovery",
+ "expired",
+ "2026-07-27T04:20:00.000Z",
+ "2026-07-27T08:20:00.000Z"
+);
+
+export const demoCancelledWatch = watch(
+ "run-start",
+ {
+ kind: "run_start",
+ runId: DEMO_WORLD.waitingRunId,
+ note: "Tell me when this run starts.",
+ maxHours: 1,
+ checkEveryMinutes: 1,
+ },
+ "run-start",
+ "cancelled",
+ "2026-07-27T10:01:00.000Z",
+ "2026-07-27T11:01:00.000Z"
+);
+
+export const demoWatchRow: DemoWatch[] = [
+ demoRunFinishedWatch,
+ demoBacklogDrainWatch,
+ demoErrorRecurrenceWatch,
+ demoHealthRecoveryWatch,
+ demoCancelledWatch,
+];
+
+export const demoActiveWatchRow: DemoWatch[] = [demoRunFinishedWatch, demoBacklogDrainWatch];
+
+export const demoWatchNarration = {
+ wake: `**The retry finished.** \`${DEMO_WORLD.failedRunId}\` completed successfully 4 minutes ago, on attempt 2 — the provider accepted the request once the delay pushed it out of the rate-limit window.
+
+I've stopped watching it. The other 40 runs from the same burst are still queued behind the concurrency limit; ask me if you want them watched too.`,
+
+ expiry: `**I've stopped watching \`${DEMO_WORLD.backlogQueue}\`.** The 6-hour window is up and the backlog never fully drained — it's down from 4,812 to 610 pending, so it's clearing, just slower than the window I was given.
+
+Ask again if you want another 6 hours.`,
+
+ expiryUnverified: `**I've stopped watching prod's health, but I couldn't verify the condition at expiry.** The health data was unavailable on my last few checks, so I can't tell you whether prod recovered — only that I never saw it recover.
+
+Re-run the health report to get a current answer.`,
+
+ cancelled: `Stopped watching \`${DEMO_WORLD.waitingRunId}\`.`,
+} as const;
+
+export const demoWatches = {
+ runFinished: demoRunFinishedWatch,
+ backlogDrain: demoBacklogDrainWatch,
+ errorRecurrence: demoErrorRecurrenceWatch,
+ healthRecovery: demoHealthRecoveryWatch,
+ cancelled: demoCancelledWatch,
+ row: demoWatchRow,
+ activeRow: demoActiveWatchRow,
+ narration: demoWatchNarration,
+} as const;
diff --git a/apps/webapp/app/components/dashboard-agent/demo/ids.ts b/apps/webapp/app/components/dashboard-agent/demo/ids.ts
index 22697e3361..1db8a9fdcb 100644
--- a/apps/webapp/app/components/dashboard-agent/demo/ids.ts
+++ b/apps/webapp/app/components/dashboard-agent/demo/ids.ts
@@ -1,10 +1,62 @@
-// Every id the demo layer produces contains "demo".
+// Every id the demo layer produces contains "demo". Resource ids carry the marker
+// inline: `trigger://` segments are percent-encoded, so `demo:` would render as `demo%3A`.
+import { formatTriggerUri, type TriggerUri } from "@internal/dashboard-agent-contracts";
+
export const DEMO_ID_PREFIX = "demo:";
+export const DEMO_MARKER = "demo";
+
export function demoId(rest: string): string {
return `${DEMO_ID_PREFIX}${rest}`;
}
+export const DEMO_PROJECT_REF = "proj_demo00000000000000";
+export const DEMO_ENVIRONMENT_ID = "env_demo00000000000000";
+
+const scope = { projectRef: DEMO_PROJECT_REF, environmentId: DEMO_ENVIRONMENT_ID };
+
+export function demoRunsUri(): TriggerUri {
+ return formatTriggerUri({ kind: "runs", ...scope });
+}
+
+export function demoRunUri(runId: string): TriggerUri {
+ return formatTriggerUri({ kind: "run", ...scope, runId });
+}
+
+export function demoSpanUri(runId: string, spanId: string): TriggerUri {
+ return formatTriggerUri({ kind: "span", ...scope, runId, spanId });
+}
+
+export function demoErrorUri(fingerprint: string): TriggerUri {
+ return formatTriggerUri({ kind: "error", ...scope, fingerprint });
+}
+
+export function demoQueueUri(name: string): TriggerUri {
+ return formatTriggerUri({ kind: "queue", ...scope, name });
+}
+
+export function demoDeploymentUri(version: string): TriggerUri {
+ return formatTriggerUri({ kind: "deployment", ...scope, version });
+}
+
+export function demoReportUri(key: string): TriggerUri {
+ return formatTriggerUri({ kind: "report", ...scope, key });
+}
+
+export function demoSourceUri(sha: string, path: string, line?: number): TriggerUri {
+ return formatTriggerUri({
+ kind: "source",
+ ...scope,
+ sha,
+ path,
+ ...(line !== undefined ? { line } : {}),
+ });
+}
+
+export function demoInvestigationUri(investigationId: string): TriggerUri {
+ return formatTriggerUri({ kind: "investigation", ...scope, investigationId });
+}
+
export const DEMO_WORLD = {
failedRunId: "run_demo0f2c91",
failedSpanId: "span_demoa41b",
diff --git a/apps/webapp/app/components/dashboard-agent/demo/index.ts b/apps/webapp/app/components/dashboard-agent/demo/index.ts
new file mode 100644
index 0000000000..62e6a04bbd
--- /dev/null
+++ b/apps/webapp/app/components/dashboard-agent/demo/index.ts
@@ -0,0 +1,7 @@
+// Must stay free of server imports. `demo.test.ts` asserts that.
+export { DEMO_ID_PREFIX, DEMO_MARKER, DEMO_WORLD, demoId, demoReportUri, demoRunsUri } from "./ids";
+
+export * as demoFixtures from "./fixtures";
+
+export { DemoChartCard } from "./components/DemoChartCard";
+export { DemoIntentBubble } from "./components/DemoIntentBubble";
diff --git a/apps/webapp/app/components/dashboard-agent/message-quota.test.ts b/apps/webapp/app/components/dashboard-agent/message-quota.test.ts
index 5a252db7ac..deb888b05d 100644
--- a/apps/webapp/app/components/dashboard-agent/message-quota.test.ts
+++ b/apps/webapp/app/components/dashboard-agent/message-quota.test.ts
@@ -1,5 +1,55 @@
import { describe, expect, it } from "vitest";
-import { countUserMessages, FREE_PLAN_MESSAGE_LIMIT, resolveMessageQuota } from "./message-quota";
+import {
+ countUserMessages,
+ FREE_PLAN_MESSAGE_LIMIT,
+ MESSAGE_QUOTA_REACHED_ERROR,
+ messageQuotaReachedCopy,
+ parseQuotaReachedResponse,
+ quotaResponseUpdate,
+ resolveMessageLimit,
+ resolveMessageQuota,
+ shouldClearCapReached,
+} from "./message-quota";
+
+describe("quotaResponseUpdate", () => {
+ it("takes both fields from a coherent body", () => {
+ expect(quotaResponseUpdate({ used: 30, limit: 50 })).toEqual({ used: 30, limit: 50 });
+ expect(quotaResponseUpdate({ used: 30, limit: null })).toEqual({ used: 30, limit: null });
+ expect(quotaResponseUpdate({ used: 0, limit: 0 })).toEqual({ used: 0, limit: 0 });
+ });
+
+ it("changes nothing on a degraded body", () => {
+ // Control break: apply `{}` field-by-field and a good {used:30, limit:50} read decays to
+ // used 30 against the client's 20 — "reached" against a cap the server never set.
+ expect(quotaResponseUpdate({})).toBeNull();
+ expect(quotaResponseUpdate(null)).toBeNull();
+ expect(quotaResponseUpdate({ limit: 50 })).toBeNull();
+ });
+});
+
+describe("resolveMessageLimit", () => {
+ it("prefers a finite server-resolved limit over the client constant", () => {
+ expect(resolveMessageLimit(5)).toBe(5);
+ expect(resolveMessageLimit(0)).toBe(0);
+ expect(resolveMessageLimit(500)).toBe(500);
+ });
+
+ it("keeps the free-plan nudge when the server has no finite limit", () => {
+ // Pre-P0 the server limit is the unlimited sentinel and is sent as null: the client's
+ // own 20 IS the nudge. Control break: thread the server number here and it disappears.
+ expect(resolveMessageLimit(null)).toBe(FREE_PLAN_MESSAGE_LIMIT);
+ expect(resolveMessageLimit(undefined)).toBe(FREE_PLAN_MESSAGE_LIMIT);
+ });
+
+ it("caps against the server limit once it is known", () => {
+ expect(
+ resolveMessageQuota({ isFreePlan: true, used: 5, limit: resolveMessageLimit(5) })
+ ).toMatchObject({ kind: "reached", limit: 5 });
+ expect(
+ resolveMessageQuota({ isFreePlan: true, used: 5, limit: resolveMessageLimit(null) })
+ ).toMatchObject({ kind: "within", limit: FREE_PLAN_MESSAGE_LIMIT, remaining: 15 });
+ });
+});
describe("resolveMessageQuota", () => {
it("caps a Free plan at the limit", () => {
@@ -42,6 +92,76 @@ describe("resolveMessageQuota", () => {
});
});
+describe("parseQuotaReachedResponse", () => {
+ it("maps a create/in 403 cap body to the limit", () => {
+ // Both the create path and the `in` transport refuse with this exact body.
+ expect(
+ parseQuotaReachedResponse(403, { error: MESSAGE_QUOTA_REACHED_ERROR, limit: 20 })
+ ).toEqual({ limit: 20, planResolved: true });
+ });
+
+ it("falls back to the free limit when the body omits it", () => {
+ expect(parseQuotaReachedResponse(403, { error: MESSAGE_QUOTA_REACHED_ERROR })).toEqual({
+ limit: FREE_PLAN_MESSAGE_LIMIT,
+ planResolved: false,
+ });
+ });
+
+ it("ignores other errors and non-403 statuses so they surface normally", () => {
+ expect(parseQuotaReachedResponse(403, { error: "something_else" })).toBeNull();
+ expect(parseQuotaReachedResponse(500, { error: MESSAGE_QUOTA_REACHED_ERROR })).toBeNull();
+ expect(parseQuotaReachedResponse(403, null)).toBeNull();
+ });
+});
+
+describe("shouldClearCapReached", () => {
+ const readQuota = (data: { used?: number; limit?: number | null } | null) => {
+ const update = quotaResponseUpdate(data);
+ return resolveMessageQuota({
+ isFreePlan: true,
+ used: update?.used,
+ limit: resolveMessageLimit(update?.limit),
+ });
+ };
+
+ it("releases the block once a read shows capacity", () => {
+ // Refused at 20/20, then the allowance resets or the plan's cap grows.
+ expect(shouldClearCapReached(readQuota({ used: 20, limit: 20 }))).toBe(false);
+ expect(shouldClearCapReached(readQuota({ used: 0, limit: 20 }))).toBe(true);
+ expect(shouldClearCapReached(readQuota({ used: 20, limit: 500 }))).toBe(true);
+ });
+
+ it("keeps the block when the read is degraded, so the composer can't flash", () => {
+ expect(shouldClearCapReached(readQuota({ used: 20, limit: 20 }))).toBe(false);
+ expect(shouldClearCapReached(readQuota(null))).toBe(false);
+ expect(shouldClearCapReached(readQuota({ limit: 20 }))).toBe(false);
+ });
+
+ it("keeps the block while the plan hasn't resolved", () => {
+ expect(shouldClearCapReached(resolveMessageQuota({ isFreePlan: undefined, used: 0 }))).toBe(
+ false
+ );
+ });
+});
+
+describe("messageQuotaReachedCopy", () => {
+ it("names the Free plan only for the client nudge", () => {
+ const copy = messageQuotaReachedCopy(FREE_PLAN_MESSAGE_LIMIT, false);
+ expect(copy).toContain(`all ${FREE_PLAN_MESSAGE_LIMIT} messages`);
+ expect(copy).toContain("Free plan");
+ // Control break: if the mapping leaked the server code, this fails.
+ expect(copy).not.toContain(MESSAGE_QUOTA_REACHED_ERROR);
+ });
+
+ it("stays plan-agnostic for a server-resolved limit, which paying orgs also hit", () => {
+ const copy = messageQuotaReachedCopy(500, true);
+ expect(copy).toContain("all 500 messages");
+ expect(copy).toContain("your plan");
+ expect(copy).not.toContain("Free plan");
+ expect(copy).not.toContain(MESSAGE_QUOTA_REACHED_ERROR);
+ });
+});
+
describe("countUserMessages", () => {
it("counts only what the user sent", () => {
expect(
diff --git a/apps/webapp/app/components/dashboard-agent/message-quota.ts b/apps/webapp/app/components/dashboard-agent/message-quota.ts
index f65481c870..227f0a0232 100644
--- a/apps/webapp/app/components/dashboard-agent/message-quota.ts
+++ b/apps/webapp/app/components/dashboard-agent/message-quota.ts
@@ -4,6 +4,27 @@ import { isWatchRequestMessageId } from "@internal/dashboard-agent-contracts";
// would reset.
export const FREE_PLAN_MESSAGE_LIMIT = 20;
+/**
+ * The cap to show: the plan limit the server resolved, when it resolved a finite one. The
+ * server sends null while no plan limit exists (self-hosted, or before billing carries one),
+ * and then the free-plan nudge is the cap — dropping it would remove the nudge entirely.
+ */
+export function resolveMessageLimit(serverLimit: number | null | undefined): number {
+ return typeof serverLimit === "number" ? serverLimit : FREE_PLAN_MESSAGE_LIMIT;
+}
+
+/**
+ * What a `?quota=1` body should change, or null for a degraded one. Both fields move together:
+ * applying a `{}` on top of a good read would keep the count and drop back to the nudge limit,
+ * which reads as "reached" against a cap the server never set.
+ */
+export function quotaResponseUpdate(
+ data: { used?: number; limit?: number | null } | null | undefined
+): { used: number; limit: number | null } | null {
+ if (typeof data?.used !== "number") return null;
+ return { used: data.used, limit: typeof data.limit === "number" ? data.limit : null };
+}
+
export type MessageQuota =
| { kind: "unlimited" }
| { kind: "within"; used: number; limit: number; remaining: number }
@@ -27,6 +48,47 @@ export function resolveMessageQuota({
: { kind: "within", used, limit, remaining };
}
+/**
+ * Whether a refusal-set cap can be released: only a read that proves capacity is back. An
+ * unknown quota (degraded read, plan not resolved) keeps the block, so the composer never
+ * flashes back for someone the server is about to refuse again.
+ */
+export function shouldClearCapReached(quota: MessageQuota): boolean {
+ return quota.kind === "within";
+}
+
+// The server code both the create and `in` paths refuse with. The client owns the copy,
+// so this code must never reach the UI as text.
+export const MESSAGE_QUOTA_REACHED_ERROR = "message_quota_reached";
+
+// Maps a 403 refusal body to the cap signal, or null for any other error. Both paths use
+// this so a `message_quota_reached` code routes to the upgrade block, never a raw toast.
+export function parseQuotaReachedResponse(
+ status: number,
+ data: { error?: string; limit?: number } | null | undefined
+): { limit: number; planResolved: boolean } | null {
+ if (status === 403 && data?.error === MESSAGE_QUOTA_REACHED_ERROR) {
+ return typeof data.limit === "number"
+ ? { limit: data.limit, planResolved: true }
+ : { limit: FREE_PLAN_MESSAGE_LIMIT, planResolved: false };
+ }
+ return null;
+}
+
+/**
+ * The upgrade block's sentence. Pure so the copy is asserted directly, and so the raw
+ * server code can never be what the user reads. Only the client's free-plan nudge may name
+ * the Free plan — a server-resolved cap also lands on paying orgs, whose allowance isn't it.
+ */
+export function messageQuotaReachedCopy(limit: number, planResolved: boolean): string {
+ return planResolved
+ ? `You've used all ${limit} messages included in your plan this month. Your chats stay here to read.`
+ : `You've used all ${limit} messages included on the Free plan. Your chats stay here to read.`;
+}
+
+/** Why a suggestion chip is disabled: the upgrade block carries the full sentence. */
+export const MESSAGE_QUOTA_REACHED_REASON = "You've used your message allowance";
+
// A watch's consent record is a user message the person never typed, so it is
// excluded here exactly as the stored count excludes it.
export function countUserMessages(messages: { role: string; id?: string }[]): number {
diff --git a/apps/webapp/app/components/dashboard-agent/useAgentMessageQuota.ts b/apps/webapp/app/components/dashboard-agent/useAgentMessageQuota.ts
index da6cc3d83b..0ddf3279f3 100644
--- a/apps/webapp/app/components/dashboard-agent/useAgentMessageQuota.ts
+++ b/apps/webapp/app/components/dashboard-agent/useAgentMessageQuota.ts
@@ -1,46 +1,65 @@
-import type { UIMessage } from "@ai-sdk/react";
-import { useEffect, useState } from "react";
-import { countUserMessages, resolveMessageQuota, type MessageQuota } from "./message-quota";
+import { useEffect, useRef, useState } from "react";
+import { useCurrentPlan } from "~/routes/_app.orgs.$organizationSlug/route";
+import {
+ quotaResponseUpdate,
+ resolveMessageLimit,
+ resolveMessageQuota,
+ type MessageQuota,
+} from "./message-quota";
-// Always undefined until billing supplies plan detection, which means no cap.
+// Gated on billing PRESENCE, not the plan value: no subscription means billing isn't wired
+// up (self-hosted), so there is no cap and no upgrade UI. A wired-up, non-paying plan is free.
function useIsFreePlan(): boolean | undefined {
- return undefined;
+ const subscription = useCurrentPlan()?.v3Subscription;
+ if (!subscription) return undefined;
+ return subscription.isPaying === false;
}
-// Counted in two halves: the server aggregates other chats, this chat's own count
-// comes from the live transcript so the message just sent counts immediately.
+// `used` is the server's per-period count for the org. Re-read once a turn settles — the
+// server increment happens mid-turn in the `.in` proxy, so reading on optimistic append
+// would lag the count by one message and show the cap a message late.
export function useAgentMessageQuota({
actionPath,
chatId,
- messages,
+ status,
}: {
actionPath: string;
chatId: string;
- messages: UIMessage[];
+ status: string;
}): MessageQuota {
const isFreePlan = useIsFreePlan();
- const [usedElsewhere, setUsedElsewhere] = useState(undefined);
+ const [used, setUsed] = useState(undefined);
+ const [serverLimit, setServerLimit] = useState(null);
+
+ // Bumped each time the status leaves streaming/submitted, which drives the re-read.
+ const [settleTick, setSettleTick] = useState(0);
+ const prevStatus = useRef(status);
+ useEffect(() => {
+ const wasInFlight = prevStatus.current === "streaming" || prevStatus.current === "submitted";
+ const nowSettled = status === "ready" || status === "error";
+ prevStatus.current = status;
+ if (wasInFlight && nowSettled) setSettleTick((tick) => tick + 1);
+ }, [status]);
useEffect(() => {
if (isFreePlan !== true) return;
const controller = new AbortController();
void (async () => {
try {
- const res = await fetch(`${actionPath}?quota=1&chatId=${encodeURIComponent(chatId)}`, {
- signal: controller.signal,
- });
+ const res = await fetch(`${actionPath}?quota=1`, { signal: controller.signal });
if (!res.ok) return;
- const data = (await res.json()) as { used?: number };
- if (typeof data.used === "number") setUsedElsewhere(data.used);
+ const update = quotaResponseUpdate(
+ (await res.json()) as { used?: number; limit?: number | null }
+ );
+ if (!update) return;
+ setUsed(update.used);
+ setServerLimit(update.limit);
} catch {
// Leave the count unknown, which means no cap. See `resolveMessageQuota`.
}
})();
return () => controller.abort();
- }, [isFreePlan, actionPath, chatId]);
+ }, [isFreePlan, actionPath, chatId, settleTick]);
- return resolveMessageQuota({
- isFreePlan,
- used: usedElsewhere === undefined ? undefined : usedElsewhere + countUserMessages(messages),
- });
+ return resolveMessageQuota({ isFreePlan, used, limit: resolveMessageLimit(serverLimit) });
}
diff --git a/apps/webapp/app/routes/api.v1.query.ts b/apps/webapp/app/routes/api.v1.query.ts
index adad14859d..5ff7f56cfe 100644
--- a/apps/webapp/app/routes/api.v1.query.ts
+++ b/apps/webapp/app/routes/api.v1.query.ts
@@ -2,7 +2,11 @@ import { json } from "@remix-run/server-runtime";
import { QueryError } from "@internal/clickhouse";
import { z } from "zod";
import { createActionApiRoute, everyResource } from "~/services/routeBuilders/apiBuilder.server";
-import { executeQuery, type QueryScope } from "~/services/queryService.server";
+import {
+ executeQuery,
+ isQueryConcurrencyRejection,
+ type QueryScope,
+} from "~/services/queryService.server";
import { logger } from "~/services/logger.server";
import { rowsToCSV } from "~/utils/dataExport";
import { detectQueryTables } from "~/v3/detectQueryTables";
@@ -78,6 +82,12 @@ const { action, loader } = createActionApiRoute(
});
if (!queryResult.success) {
+ // A concurrency rejection is "too busy", not a bad query: 429 so callers retry it
+ // instead of rewriting a query that was fine.
+ if (isQueryConcurrencyRejection(queryResult.error)) {
+ return json({ error: queryResult.error.message }, { status: 429 });
+ }
+
// QueryError surfaces customer SQL problems (invalid syntax,
// unsupported construct). Returned to the caller as 400; system
// handles it gracefully, no alert needed.
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.in.$.ts b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.in.$.ts
index 5939e836db..e42acbd94c 100644
--- a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.in.$.ts
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.in.$.ts
@@ -7,6 +7,7 @@ import {
MESSAGE_TOO_LARGE_CODE,
MESSAGE_TOO_LARGE_ERROR,
} from "~/components/dashboard-agent/message-limits";
+import { MESSAGE_QUOTA_REACHED_ERROR } from "~/components/dashboard-agent/message-quota";
import { findProjectBySlug } from "~/models/project.server";
import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
import {
@@ -15,6 +16,13 @@ import {
resolveDashboardAgentRepoSnapshot,
} from "~/services/dashboardAgent.server";
import { dashboardAgentEnvironmentAddress } from "~/services/dashboardAgentEnvironmentAddress.server";
+import { dashboardAgentDb } from "~/services/dashboardAgentDb.server";
+import { wellFormMessageText } from "~/services/dashboardAgentMessageText.server";
+import {
+ agentTurnCountsAgainstQuota,
+ recordAgentMessageSent,
+ resolveAgentMessageQuota,
+} from "~/services/dashboardAgentQuota.server";
import { logger } from "~/services/logger.server";
import { requireUser } from "~/services/session.server";
import { readBoundedBodyText } from "~/utils/boundedRequestBody.server";
@@ -115,6 +123,9 @@ export async function action({ request, params }: ActionFunctionArgs) {
parsed = undefined;
}
+ // Hoisted so it is visible after the fetch: quota is charged only once the send succeeds.
+ let countsAgainstQuota = false;
+
if (parsed) {
// Actions are placed by the server only, and this proxy is the one path a browser
// can reach `.in` through.
@@ -127,6 +138,19 @@ export async function action({ request, params }: ActionFunctionArgs) {
return tooLarge();
}
+ wellFormMessageText(parsed.payload.message?.parts);
+
+ // Only a real user message consumes quota; action turns were refused above.
+ countsAgainstQuota = agentTurnCountsAgainstQuota(parsed);
+ if (countsAgainstQuota) {
+ const quota = await resolveAgentMessageQuota(dashboardAgentDb, {
+ organizationId: project.organizationId,
+ });
+ if (quota?.reached) {
+ return json({ error: MESSAGE_QUOTA_REACHED_ERROR, limit: quota.limit }, { status: 403 });
+ }
+ }
+
let userActorToken: string;
try {
userActorToken = await mintDashboardAgentUserActorToken(user.id, {
@@ -165,6 +189,13 @@ export async function action({ request, params }: ActionFunctionArgs) {
try {
const upstream = await fetch(upstreamUrl, { method: "POST", headers, body });
const text = await upstream.text();
+ // Charge quota only for a delivered message: a non-2xx upstream (or a throw below)
+ // must not burn a send that never reached the agent.
+ if (countsAgainstQuota && upstream.ok) {
+ await recordAgentMessageSent(dashboardAgentDb, {
+ organizationId: project.organizationId,
+ });
+ }
return new Response(text, {
status: upstream.status,
headers: { "content-type": upstream.headers.get("content-type") ?? "application/json" },
diff --git a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.ts b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.ts
index d808c56754..499e621b83 100644
--- a/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.ts
+++ b/apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.ts
@@ -3,7 +3,6 @@ import {
chatExists,
countUnreadWatchWakes,
countChatsWithUnreadWork,
- countUserMessages,
createChat,
getChatMessages,
getSession,
@@ -28,6 +27,7 @@ import {
MESSAGE_TOO_LARGE_CODE,
MESSAGE_TOO_LARGE_ERROR,
} from "~/components/dashboard-agent/message-limits";
+import { MESSAGE_QUOTA_REACHED_ERROR } from "~/components/dashboard-agent/message-quota";
import { MAX_URIS_PER_RESOLVE_REQUEST } from "~/components/dashboard-agent/resolve-uris";
import { $replica } from "~/db.server";
import { env } from "~/env.server";
@@ -50,9 +50,15 @@ import {
startDashboardAgentSession,
} from "~/services/dashboardAgent.server";
import { dashboardAgentEnvironmentAddress } from "~/services/dashboardAgentEnvironmentAddress.server";
+import { wellFormMessageText } from "~/services/dashboardAgentMessageText.server";
import { watchErrorStatus } from "~/services/dashboardAgentWatchErrorStatus.server";
import { startDashboardAgentHeadStart } from "~/services/dashboardAgentHeadStart.server";
import { dashboardAgentDb } from "~/services/dashboardAgentDb.server";
+import {
+ recordAgentMessageSent,
+ resolveAgentMessageQuota,
+ UNLIMITED_AGENT_MESSAGES,
+} from "~/services/dashboardAgentQuota.server";
import { logger } from "~/services/logger.server";
import { resolveTriggerUri } from "~/services/resolveTriggerUri.server";
import { requireUser } from "~/services/session.server";
@@ -151,15 +157,18 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const project = await findProjectBySlug(organizationSlug, projectParam, userId);
if (!project) return json({ error: "Project not found" }, { status: 404 });
- // The open chat is excluded and counted from the live transcript instead, so an
- // unpersisted turn still counts against the cap.
+ // The per-period counter, org-wide: a deleted chat can't lower it within the period.
if (searchParams.get("quota") === "1") {
- const used = await countUserMessages(dashboardAgentDb, {
+ const quota = await resolveAgentMessageQuota(dashboardAgentDb, {
organizationId: project.organizationId,
- userId,
- excludeChatId: searchParams.get("chatId") ?? undefined,
});
- return json({ used });
+ if (!quota) return json({});
+ // The sentinel is "no plan limit" — send null so the client keeps its own free-plan nudge
+ // instead of showing a number nobody would ever reach.
+ return json({
+ used: quota.used,
+ limit: quota.limit < UNLIMITED_AGENT_MESSAGES ? quota.limit : null,
+ });
}
const chatId = searchParams.get("chatId");
@@ -291,6 +300,15 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
return messageTooLarge();
}
+ wellFormMessageText(firstMessage.parts);
+
+ const quota = await resolveAgentMessageQuota(dashboardAgentDb, {
+ organizationId: project.organizationId,
+ });
+ if (quota?.reached) {
+ return json({ error: MESSAGE_QUOTA_REACHED_ERROR, limit: quota.limit }, { status: 403 });
+ }
+
let clientData: Record | undefined;
try {
clientData = parsed.data.clientData
@@ -388,6 +406,14 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
throw error;
}
+ // Only the head start dispatches the first message here; a cold start sends it through
+ // the `in` proxy, which counts it there. Counting both would double-count.
+ if (headStarted) {
+ await recordAgentMessageSent(dashboardAgentDb, {
+ organizationId: project.organizationId,
+ });
+ }
+
let publicAccessToken: string;
try {
publicAccessToken = await mintDashboardAgentToken(chatId);
diff --git a/apps/webapp/app/routes/storybook.agent-investigation/route.tsx b/apps/webapp/app/routes/storybook.agent-investigation/route.tsx
new file mode 100644
index 0000000000..518f8740ad
--- /dev/null
+++ b/apps/webapp/app/routes/storybook.agent-investigation/route.tsx
@@ -0,0 +1,87 @@
+import {
+ INVESTIGATION_CAPABILITIES_VERSION,
+ type InvestigationCapabilities,
+} from "@internal/dashboard-agent-contracts";
+import { demoFixtures } from "~/components/dashboard-agent/demo";
+import { InvestigationCard } from "~/components/dashboard-agent/InvestigationCard";
+import { investigationBlock } from "../storybook.agent-ui/fixtures";
+import { fixtureResolveUri, GalleryPage, noop } from "../storybook.agent-ui/gallery";
+
+const { demoInvestigations } = demoFixtures;
+
+const citedUri = (
+ fixture: (typeof demoInvestigations)[keyof typeof demoInvestigations],
+ kind: string
+) => fixture.evidence.find((evidence) => evidence.kind === kind)!.uri;
+
+const codeGroundedCapabilities: InvestigationCapabilities = {
+ version: INVESTIGATION_CAPABILITIES_VERSION,
+ actions: [
+ {
+ kind: "show_code",
+ label: "Show code",
+ intent: {
+ kind: "ask",
+ prompt:
+ "Show me the code behind this and propose the minimal fix as a fenced diff, anchored to the file, line and commit you read.",
+ },
+ },
+ {
+ kind: "view_similar",
+ label: "View similar failures",
+ intent: { kind: "navigate", target: citedUri(demoInvestigations.concluded, "error") },
+ },
+ ],
+};
+
+const notCodeGroundedCapabilities: InvestigationCapabilities = {
+ version: INVESTIGATION_CAPABILITIES_VERSION,
+ actions: [
+ {
+ kind: "view_similar",
+ label: "View the queue",
+ intent: { kind: "navigate", target: citedUri(demoInvestigations.concludedNoCode, "queue") },
+ },
+ ],
+};
+
+const STATES: Record = {
+ "investigation-card-streaming-rev1": (
+
+ ),
+ "investigation-card-concluded": (
+
+ ),
+ "investigation-card-concluded-code-grounded": (
+
+ ),
+ "investigation-card-concluded-not-code-grounded": (
+
+ ),
+ "investigation-card-inconclusive": (
+
+ ),
+ "investigation-card-degraded": (
+
+ ),
+};
+
+export default function Story() {
+ return ;
+}
diff --git a/apps/webapp/app/routes/storybook.agent-report/route.tsx b/apps/webapp/app/routes/storybook.agent-report/route.tsx
new file mode 100644
index 0000000000..7382176ab6
--- /dev/null
+++ b/apps/webapp/app/routes/storybook.agent-report/route.tsx
@@ -0,0 +1,32 @@
+import { DEMO_WORLD, demoFixtures, demoReportUri } from "~/components/dashboard-agent/demo";
+import { ReportView } from "~/components/dashboard-agent/ReportView";
+import { untrustworthyReport } from "../storybook.agent-ui/fixtures";
+import { fixtureResolveUri, GalleryPage, noop } from "../storybook.agent-ui/gallery";
+
+const reportUri = demoReportUri(DEMO_WORLD.reportKey);
+
+const STATES: Record = {
+ "report-view-healthy": (
+
+ ),
+ "report-view-degraded": (
+
+ ),
+ "report-view-untrustworthy": (
+
+ ),
+};
+
+export default function Story() {
+ return ;
+}
diff --git a/apps/webapp/app/routes/storybook.agent-ui/fixtures.test.ts b/apps/webapp/app/routes/storybook.agent-ui/fixtures.test.ts
new file mode 100644
index 0000000000..7cb3e72829
--- /dev/null
+++ b/apps/webapp/app/routes/storybook.agent-ui/fixtures.test.ts
@@ -0,0 +1,174 @@
+import {
+ safeParseStoredViewBlock,
+ viewBlockSchema,
+ watchExternalNotificationLine,
+} from "@internal/dashboard-agent-contracts";
+import { ErrorId } from "@trigger.dev/core/v3/isomorphic";
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { DEMO_MARKER } from "~/components/dashboard-agent/demo/ids";
+import { planDiagnosisActions } from "~/components/dashboard-agent/diagnosis-actions";
+import { renderableActions } from "~/components/dashboard-agent/view-actions";
+import { reportTrust } from "~/presenters/v3/reports/report-layout";
+import {
+ externalServiceDiagnosis,
+ fullDiagnosis,
+ lowConfidenceDiagnosis,
+ offerActionsBlock,
+ revisedDiagnosisBlocks,
+ untrustworthyReport,
+ watchConfirmationBlock,
+ watchDegradedConfirmationBlock,
+ watchSatisfiedBlock,
+} from "./fixtures";
+
+/**
+ * The gallery's hand-written fixtures, checked against the code that reads them rather
+ * than against themselves. A fixture that still typechecks but no longer matches what
+ * the product emits would otherwise render a state nobody can reach.
+ */
+
+describe("gallery view blocks", () => {
+ it("parses every enveloped block through the schema the product persists with", () => {
+ for (const block of [
+ ...revisedDiagnosisBlocks,
+ offerActionsBlock,
+ watchConfirmationBlock,
+ watchDegradedConfirmationBlock,
+ watchSatisfiedBlock,
+ ]) {
+ const result = viewBlockSchema.safeParse(block);
+ expect(result.success, JSON.stringify(result.error?.issues)).toBe(true);
+ }
+ });
+
+ it("parses the envelope-less diagnoses through the stored-block schema", () => {
+ for (const block of [fullDiagnosis, externalServiceDiagnosis, lowConfidenceDiagnosis]) {
+ const result = safeParseStoredViewBlock(block);
+ expect(result.success, JSON.stringify(result.error?.issues)).toBe(true);
+ }
+ });
+
+ /** Every stored spec is normalized, so an unprefixed fingerprint is a shape no card sees. */
+ it("cites error fingerprints in the normalized form the watch service stores", () => {
+ for (const action of offerActionsBlock.actions) {
+ if (action.intent.kind !== "watch" || action.intent.spec.kind !== "error_recurrence")
+ continue;
+ const { fingerprint } = action.intent.spec;
+ expect(fingerprint).toBe(ErrorId.toId(fingerprint));
+ }
+ });
+
+ it("offers only actions the panel would render", () => {
+ expect(renderableActions(offerActionsBlock.actions)).toHaveLength(
+ offerActionsBlock.actions.length
+ );
+ });
+
+ /**
+ * The gallery renders outside a project route, so the card resolves no run path and drops
+ * the button. With a resolver both survive: the fixture's actions are still ones the card
+ * can plan, not ones it silently discards.
+ */
+ it("plans every diagnosis action once its destination resolves", () => {
+ const planned = planDiagnosisActions(fullDiagnosis.actions ?? [], {
+ runPath: (runId) => `/runs/${runId}`,
+ docsUrl: (target) => target,
+ });
+ expect(planned.map((action) => action.kind)).toEqual(["view_run", "docs"]);
+ });
+});
+
+/**
+ * `demo.test.ts` marks the demo layer's ids. These fixtures are hand-written next to the
+ * route, so the same rule is asserted here: a `view_run` or `navigate` the presenter can
+ * resolve must land on demo data, never on somebody's environment.
+ */
+describe("gallery identifiers", () => {
+ // The digit keeps discriminants like `error_recurrence` out; ids always carry one.
+ const IDENTIFIER = /^(run|error|watch|queue|proj|env|deployment)_[a-z0-9]*\d|^trigger:\/\//i;
+
+ function strings(value: unknown, path = "fixture"): Array<[string, string]> {
+ if (typeof value === "string") return [[value, path]];
+ if (Array.isArray(value)) return value.flatMap((item, i) => strings(item, `${path}[${i}]`));
+ if (value && typeof value === "object") {
+ return Object.entries(value).flatMap(([key, item]) => strings(item, `${path}.${key}`));
+ }
+ return [];
+ }
+
+ const fixtures = {
+ fullDiagnosis,
+ externalServiceDiagnosis,
+ lowConfidenceDiagnosis,
+ revisedDiagnosisBlocks,
+ offerActionsBlock,
+ watchConfirmationBlock,
+ watchDegradedConfirmationBlock,
+ watchSatisfiedBlock,
+ untrustworthyReport,
+ };
+
+ it("names no resource that isn't demo data", () => {
+ for (const [value, path] of strings(fixtures)) {
+ if (!IDENTIFIER.test(value)) continue;
+ expect(value, path).toContain(DEMO_MARKER);
+ }
+ });
+
+ it("watches only demo subjects, whatever shape their id takes", () => {
+ for (const action of offerActionsBlock.actions) {
+ if (action.intent.kind !== "watch") continue;
+ const subject = Object.entries(action.intent.spec).filter(([key]) =>
+ ["queue", "runId", "fingerprint"].includes(key)
+ );
+ expect(subject.length).toBeGreaterThan(0);
+ for (const [key, value] of subject) expect(String(value), key).toContain(DEMO_MARKER);
+ }
+ });
+});
+
+describe("gallery watch confirmations", () => {
+ it("states the external outcome each confirmation claims", () => {
+ expect(watchConfirmationBlock.followUp).toContain(
+ watchExternalNotificationLine({ status: "enabled" })
+ );
+ expect(watchDegradedConfirmationBlock.followUp).toContain(
+ watchExternalNotificationLine({
+ status: "unavailable",
+ reason: "email_alerts_not_configured",
+ })
+ );
+ });
+
+ it("says the first check could not run on the degraded one, and not on the other", () => {
+ expect(watchDegradedConfirmationBlock.detail).toBeTruthy();
+ expect(watchConfirmationBlock.detail).toBeNull();
+ });
+});
+
+describe("gallery report", () => {
+ it("names an untrustworthy reason the card has a caveat for", () => {
+ const trust = reportTrust(untrustworthyReport);
+ expect(trust?.badge).toBe("stale data");
+ });
+});
+
+/**
+ * `demo/index.ts` re-exports `DemoChartCard` and `DemoIntentBubble`, so importing it here would
+ * pull React components into a suite that runs without a DOM. `demo.test.ts` reaches past the
+ * barrel for the same reason; these fixtures and their test do too.
+ *
+ * Structural: what a module drags in is not observable from inside it.
+ */
+describe("the gallery fixtures stay out of the demo barrel", () => {
+ const BARREL = /from "~\/components\/dashboard-agent\/demo"/;
+
+ for (const file of ["fixtures.ts", "fixtures.test.ts"]) {
+ it(`${file} reaches past it`, () => {
+ const source = readFileSync(new URL(`./${file}`, import.meta.url), "utf8");
+ expect(BARREL.test(source), `${file} imports the demo barrel`).toBe(false);
+ expect(source).toContain('"~/components/dashboard-agent/demo/');
+ });
+ }
+});
diff --git a/apps/webapp/app/routes/storybook.agent-ui/fixtures.ts b/apps/webapp/app/routes/storybook.agent-ui/fixtures.ts
new file mode 100644
index 0000000000..abb49e1826
--- /dev/null
+++ b/apps/webapp/app/routes/storybook.agent-ui/fixtures.ts
@@ -0,0 +1,410 @@
+import type { UIMessage } from "@ai-sdk/react";
+import {
+ VIEW_BLOCK_VERSION,
+ type DiagnosisBlock,
+ type InvestigationBlock,
+ type InvestigationCapabilities,
+ type ReportViewModelPayload,
+ type ViewBlock,
+ type WatchResultBlock as WatchResultBlockPayload,
+} from "@internal/dashboard-agent-contracts";
+import * as demoFixtures from "~/components/dashboard-agent/demo/fixtures";
+import { DEMO_WORLD, demoId, demoRunsUri } from "~/components/dashboard-agent/demo/ids";
+import type { TurnActivity } from "~/components/dashboard-agent/DashboardAgentMessages";
+import { watchConfirmationBlockBody, watchOneShotBlockBody } from "~/presenters/v3/dashboardAgent";
+import {
+ queueWatchRecommendation,
+ runWatchRecommendation,
+} from "~/components/dashboard-agent/watch-recommendations";
+
+export function investigationBlock(
+ fixture: (typeof demoFixtures.demoInvestigations)[keyof typeof demoFixtures.demoInvestigations],
+ capabilities?: InvestigationCapabilities
+): InvestigationBlock {
+ const { investigationId, revision, ...investigation } = fixture;
+ return {
+ type: "investigation",
+ id: investigationId,
+ revision,
+ version: VIEW_BLOCK_VERSION,
+ investigation,
+ ...(capabilities ? { capabilities } : {}),
+ };
+}
+
+const {
+ assistantMessage,
+ demoDiagnosisBlockFirstPass,
+ demoDiagnosisBlockRevised,
+ demoLegacyDiagnosisBlock,
+ failedToolPart,
+ pendingToolPart,
+ reasoningPart,
+ renderViewPart,
+ sourceUrlPart,
+ streamingTextPart,
+ textPart,
+ toolPart,
+ userMessage,
+} = demoFixtures;
+
+const DEMO_WATCH_ID = demoId("watch_gallery");
+
+// A stored error_recurrence spec holds the internal id, so the demo one drops its prefix.
+const DEMO_FINGERPRINT = DEMO_WORLD.errorFingerprint.replace(/^error_/, "");
+
+/** One transcript the message gallery renders, with the turn state it belongs to. */
+export type DemoTranscript = {
+ messages: UIMessage[];
+ activity?: TurnActivity;
+ /** The turn's failure. Only the section that asks for it renders one. */
+ error?: string;
+};
+
+export const demoTranscripts = {
+ streamingText: {
+ activity: "working",
+ messages: [
+ userMessage("stream-q", "What's failing right now?"),
+ assistantMessage("stream-a", [
+ toolPart("query_runs", { period: "1h" }, { failures: 41 }, "query-runs-streaming"),
+ streamingTextPart(
+ "41 runs failed in the last hour, and they're all `send-order-receipt`. The error is the same every time — a 429 from the email provider, which means"
+ ),
+ ]),
+ ],
+ },
+
+ reasoning: {
+ activity: "working",
+ messages: [
+ userMessage("inv-q", "Why did this run fail?"),
+ assistantMessage("inv-step1", [
+ reasoningPart(
+ "Start from the run itself: status, attempts, and which span failed. Don't guess at a cause before reading the error."
+ ),
+ toolPart(
+ "get_run_details",
+ { runId: DEMO_WORLD.failedRunId },
+ {
+ runId: DEMO_WORLD.failedRunId,
+ status: "COMPLETED_WITH_ERROR",
+ attempts: 3,
+ error: "ProviderError: 429 Too Many Requests",
+ },
+ "get-run-details"
+ ),
+ textPart(
+ `\`${DEMO_WORLD.failedRunId}\` failed three times in 19 seconds, every attempt with the same error from the email provider. Three things could produce that, so I'll test them one at a time rather than settle on the first plausible one.`
+ ),
+ ]),
+ ],
+ },
+
+ toolInFlight: {
+ activity: "working",
+ messages: [
+ userMessage("tool-q", "Check the queue depth for me."),
+ assistantMessage("tool-intro", [
+ textPart(
+ `Counting what's pending across the environment first, then pulling \`${DEMO_WORLD.queue}\` on its own so we can see whether the depth is one queue or all of them.`
+ ),
+ ]),
+ assistantMessage("tool-a", [
+ toolPart(
+ "run_query",
+ { query: "SELECT count() FROM task_runs WHERE status = 'PENDING'" },
+ { rows: [{ "count()": 4812 }] },
+ "run-query-done"
+ ),
+ pendingToolPart(
+ "get_queue",
+ { queue: DEMO_WORLD.queue, period: "1h" },
+ "get-queue-pending"
+ ),
+ ]),
+ ],
+ },
+
+ errorRetry: {
+ error: "The chat stopped unexpectedly. Nothing was saved for this turn.",
+ messages: [
+ userMessage("err-q", "Chart failures by task for the last week."),
+ assistantMessage("err-a", [
+ failedToolPart(
+ "run_query",
+ { query: "SELECT task_identifier, count() FROM task_runs", period: "7d" },
+ "query timed out after 30s",
+ "run-query-failed"
+ ),
+ ]),
+ ],
+ },
+
+ // Cut before the follow-up turn: this section is about the one `render_view` part,
+ // which carries two revisions of a diagnosis plus an envelope-less legacy block.
+ renderView: {
+ messages: [
+ userMessage("res-q", "Did this happen last month too?"),
+ assistantMessage("res-a", [
+ textPart(
+ `Yes — same error, same task, three weeks ago. \`${DEMO_WORLD.taskId}\` hit the same rate limit on 6 July and it was diagnosed then too; the card below is that diagnosis, replayed from this conversation rather than re-run. The retry config hasn't changed since, which is why it came back.`
+ ),
+ renderViewPart(
+ [demoDiagnosisBlockFirstPass, demoDiagnosisBlockRevised, demoLegacyDiagnosisBlock],
+ "render-view-resumed"
+ ),
+ ]),
+ ],
+ },
+
+ docsSources: {
+ messages: [
+ userMessage("docs-q", "How do retries actually work? Is the delay exponential?"),
+ assistantMessage("docs-a", [
+ toolPart(
+ "search_docs",
+ { query: "retry configuration exponential backoff" },
+ { hits: 3 },
+ "search-docs"
+ ),
+ textPart(
+ `Yes — retries back off exponentially by default.
+
+- \`maxAttempts\` counts the *first* attempt, so \`3\` means one try plus two retries.
+- The delay is \`minTimeoutInMs * factor^(attempt - 1)\`, capped at \`maxTimeoutInMs\`.
+- \`randomize: true\` adds jitter, which is what stops a whole batch retrying in lockstep — the thing that bit \`${DEMO_WORLD.taskId}\` above.`
+ ),
+ sourceUrlPart("https://trigger.dev/docs/errors-retrying", "Errors & retrying"),
+ sourceUrlPart("https://trigger.dev/docs/tasks/overview", "Task options"),
+ ]),
+ ],
+ },
+} satisfies Record;
+
+/* ------------------------------------------------------------------ *
+ * View blocks
+ * ------------------------------------------------------------------ */
+
+export const fullDiagnosis: DiagnosisBlock = {
+ type: "diagnosis",
+ runId: DEMO_WORLD.failedRunId,
+ summary:
+ "The run failed because processOrder threw on an order with no line items. The payload had an empty items array.",
+ category: "user_code_error",
+ likelyCause:
+ "processOrder calls order.items[0] without checking length, so an empty items array throws a TypeError before any work happens.",
+ confidence: "high",
+ evidence: [
+ {
+ type: "error",
+ detail: "TypeError: Cannot read properties of undefined (reading 'sku')",
+ reference: DEMO_WORLD.failedRunId,
+ },
+ { type: "failed_span", detail: "processOrder attempt 1 failed after 42ms" },
+ {
+ type: "source",
+ detail: "The throwing line reads order.items[0].sku with no guard.",
+ reference: "src/trigger/processOrder.ts:18",
+ },
+ {
+ type: "historical_match",
+ detail: "14 runs of this task hit the same error in the last 24h.",
+ reference: DEMO_WORLD.errorFingerprint,
+ },
+ ],
+ impact:
+ "14 runs of process-order failed with this error in the last 24 hours, all in production.",
+ nextSteps: [
+ "Guard against an empty items array at the top of processOrder and return early.",
+ "Validate the payload before triggering so empty orders never reach the task.",
+ ],
+ actions: [
+ { label: "View run", kind: "view_run", target: DEMO_WORLD.failedRunId },
+ { label: "Retries docs", kind: "docs", target: "https://trigger.dev/docs/errors-retrying" },
+ ],
+};
+
+export const externalServiceDiagnosis: DiagnosisBlock = {
+ type: "diagnosis",
+ runId: DEMO_WORLD.slowRunId,
+ summary: "chargePayment timed out waiting on the Stripe API after 30 seconds.",
+ category: "external_service",
+ likelyCause:
+ "The Stripe call has no timeout or retry, so a slow upstream response runs past the task's max duration.",
+ confidence: "medium",
+ evidence: [
+ {
+ type: "error",
+ detail: "TimeoutError: Stripe API timed out after 30s",
+ reference: DEMO_WORLD.slowRunId,
+ },
+ { type: "deploy", detail: "First seen on version 20260620.2", reference: "20260620.2" },
+ ],
+ impact: "Intermittent: 3 of the last 50 charge-payment runs timed out.",
+ nextSteps: [
+ "Wrap the Stripe call in a retry with backoff.",
+ "Set an explicit request timeout shorter than the task's max duration.",
+ ],
+ actions: [{ label: "View run", kind: "view_run", target: DEMO_WORLD.slowRunId }],
+};
+
+export const lowConfidenceDiagnosis: DiagnosisBlock = {
+ type: "diagnosis",
+ runId: DEMO_WORLD.priorRunId,
+ summary:
+ "The run crashed without a captured error, so the cause isn't conclusive from the available signals.",
+ category: "unknown",
+ likelyCause:
+ "The container exited without writing an error. This is consistent with an out-of-memory kill, but there's no OOM signal in the trace to confirm it.",
+ confidence: "low",
+ evidence: [
+ { type: "failed_span", detail: "Root span ended with status CRASHED and no error payload." },
+ { type: "logs", detail: "Logs stop abruptly mid-execution with no stack trace." },
+ ],
+ nextSteps: [
+ "Re-run with a larger machine to rule out out-of-memory.",
+ "Add logging around the last successful step to narrow where it stops.",
+ ],
+};
+
+export const revisedDiagnosisBlocks: ViewBlock[] = [
+ {
+ ...lowConfidenceDiagnosis,
+ id: `diagnosis-${DEMO_WORLD.failedRunId}`,
+ revision: 1,
+ version: VIEW_BLOCK_VERSION,
+ summary: "Revision 1 — first guess, before the logs came back. Should not render.",
+ },
+ {
+ ...externalServiceDiagnosis,
+ id: `diagnosis-${DEMO_WORLD.failedRunId}`,
+ revision: 2,
+ version: VIEW_BLOCK_VERSION,
+ summary: "Revision 2 — narrowed to the payload, still unconfirmed. Should not render.",
+ },
+ {
+ ...fullDiagnosis,
+ id: `diagnosis-${DEMO_WORLD.failedRunId}`,
+ revision: 3,
+ version: VIEW_BLOCK_VERSION,
+ summary:
+ "Revision 3 — the only card that should render: processOrder threw on an order with no line items.",
+ },
+];
+
+export const offerActionsBlock: ViewBlock = {
+ type: "actions",
+ id: "actions-offer",
+ revision: 0,
+ version: VIEW_BLOCK_VERSION,
+ actions: [
+ {
+ label: "Set up a watch",
+ intent: {
+ kind: "watch",
+ spec: {
+ kind: "error_recurrence",
+ fingerprint: DEMO_FINGERPRINT,
+ checkEveryMinutes: 15,
+ maxHours: 6,
+ note: "the TypeError in send-order-receipt",
+ },
+ },
+ },
+ {
+ label: "See its failed runs",
+ intent: { kind: "navigate", target: demoRunsUri() },
+ },
+ ],
+};
+
+/* ------------------------------------------------------------------ *
+ * Watch result blocks
+ * ------------------------------------------------------------------ */
+
+const WATCH_BLOCK_ENVELOPE = {
+ id: `watch:${DEMO_WATCH_ID}`,
+ revision: 0,
+ version: VIEW_BLOCK_VERSION,
+} as const;
+
+/** Both opt-ins took effect: the happy path a submit with `notifyExternally` produces. */
+export const watchConfirmationBlock: WatchResultBlockPayload = {
+ ...watchConfirmationBlockBody({
+ spec: queueWatchRecommendation(DEMO_WORLD.queue),
+ watchId: DEMO_WATCH_ID,
+ followUp: { investigateOnAttention: true, external: { status: "enabled" } },
+ }),
+ ...WATCH_BLOCK_ENVELOPE,
+};
+
+/**
+ * The same submit, degraded: the creation-time check couldn't run and the email
+ * subscription failed. Neither fails the watch — both are said out loud instead.
+ */
+export const watchDegradedConfirmationBlock: WatchResultBlockPayload = {
+ ...watchConfirmationBlockBody({
+ spec: queueWatchRecommendation(DEMO_WORLD.queue),
+ watchId: DEMO_WATCH_ID,
+ unavailable: true,
+ followUp: {
+ investigateOnAttention: true,
+ external: { status: "unavailable", reason: "email_alerts_not_configured" },
+ },
+ }),
+ ...WATCH_BLOCK_ENVELOPE,
+};
+
+export const watchSatisfiedBlock: WatchResultBlockPayload = {
+ ...watchOneShotBlockBody({
+ spec: runWatchRecommendation(DEMO_WORLD.failedRunId),
+ result: "satisfied",
+ }),
+ ...WATCH_BLOCK_ENVELOPE,
+};
+
+/* ------------------------------------------------------------------ *
+ * Reports
+ * ------------------------------------------------------------------ */
+
+/** Every number is informational: the verdict stands but the card must say why. */
+export const untrustworthyReport: ReportViewModelPayload = {
+ ...demoFixtures.demoDegradedReport,
+ summary: {
+ severity: "crit",
+ statements: [
+ { findingType: "flow", severity: "crit", reason: "unknown" },
+ { findingType: "execution", severity: "crit", reason: "unknown" },
+ { findingType: "liveness", severity: "crit" },
+ ],
+ },
+ findings: demoFixtures.demoDegradedReport.findings.map((finding) =>
+ finding.type === "liveness"
+ ? {
+ ...finding,
+ severity: "crit",
+ reason: "stale",
+ recommendation: { code: "check_control_plane", link: "status" },
+ }
+ : {
+ ...finding,
+ severity: "crit",
+ reason: "unknown",
+ recommendation: undefined,
+ attribution: undefined,
+ exclusions: undefined,
+ observations: undefined,
+ hedge: undefined,
+ anomalyWindow: undefined,
+ }
+ ),
+ metrics: demoFixtures.demoDegradedReport.metrics.map((metric) =>
+ metric.id === "liveness"
+ ? { ...metric, value: 21 * 60_000, severity: "crit" }
+ : { ...metric, annotation: undefined }
+ ),
+ facts: { trustworthy: false, untrustworthyReason: "telemetry_stale" },
+ links: [{ key: "status", label: "status.trigger.dev", url: "https://status.trigger.dev" }],
+ footer: [{ code: "check_control_plane", link: "status" }],
+};
diff --git a/apps/webapp/app/routes/storybook.agent-ui/gallery.tsx b/apps/webapp/app/routes/storybook.agent-ui/gallery.tsx
new file mode 100644
index 0000000000..5a88c0a304
--- /dev/null
+++ b/apps/webapp/app/routes/storybook.agent-ui/gallery.tsx
@@ -0,0 +1,166 @@
+import { Link } from "@remix-run/react";
+import { safeParseTriggerUri } from "@internal/dashboard-agent-contracts";
+import { Header1, Header2 } from "~/components/primitives/Headers";
+import { Paragraph } from "~/components/primitives/Paragraph";
+import { cn } from "~/utils/cn";
+import {
+ GALLERY_PAGES,
+ groupsOnPage,
+ sectionsInGroup,
+ sectionsOnPage,
+ type GalleryPageId,
+ type GallerySection,
+} from "./manifest";
+
+export const noop = () => undefined;
+
+export const PANEL = "w-[380px]";
+
+const CANVAS = "bg-background-bright";
+
+export const PANEL_FRAME = "rounded-lg border border-border-bright bg-background-bright";
+
+export function Missing({ what }: { what: string }) {
+ return (
+
+ No renderer for {what}. The manifest and the gallery are out of sync.
+
+
+
+ {meta.blurb} {sections.length} states, rendered in isolation at panel width (380px) from
+ the demo fixtures in{" "}
+ app/components/dashboard-agent/demo/fixtures.
+ The list lives in manifest.ts.
+
+
+ Run ids, queues, errors and reports are fabricated. Deep links resolve inside a project,
+ so here they render as plain text or navigate nowhere. The theme buttons flip{" "}
+ data-theme on the root element.
+
+
- Dashboard agent UI
-
- Blocks the dashboard agent renders via its render_view tool, shown through the same
- ViewBlocks registry the chat panel uses. The catalog has the diagnosis (failure) card,
- shown here, and a chart block that runs a TRQL query live (only renders inside a
- project/env, so it's not shown here). Run links resolve inside a project; here they render
- as plain text.
-
+