@agent-native/core 0.84.13 → 0.84.16

package/corpus/core/src/client/agent-chat-adapter.ts

@@ -1461,8 +1461,29 @@ export function createAgentChatAdapter(
       const nextContinuationToolCallId = () =>
         `continuation_tc_${++continuationToolCallCounter}`;
 
+      const runDebugContextDetails = (): string => {
+        const pageOrigin =
+          typeof window !== "undefined" && window.location?.origin
+            ? window.location.origin
+            : "";
+        return [
+          `api_url: ${apiUrl}`,
+          pageOrigin ? `page_origin: ${pageOrigin}` : "",
+          tabId ? `tab_id: ${tabId}` : "",
+          threadId ? `thread_id: ${threadId}` : "",
+          `turn_id: ${turnId}`,
+          runId ? `current_run: ${runId}` : "",
+          attemptedRunIds.length > 0
+            ? `attempted_runs: ${attemptedRunIds.join(", ")}`
+            : "",
+        ]
+          .filter(Boolean)
+          .join("\n");
+      };
+
       const connectionRecoveryDetails = (): string => {
         return [
+          runDebugContextDetails(),
           lastAutoContinueReason
             ? `last_auto_continue_reason: ${lastAutoContinueReason}`
             : "",
@@ -1488,9 +1509,6 @@ export function createAgentChatAdapter(
             ? `activity_trail: ${formatActivityTrail(lastActivityTrail)}`
             : "",
           `total_transient_continuations: ${totalTransientContinuationAttempts}`,
-          attemptedRunIds.length > 0
-            ? `attempted_runs: ${attemptedRunIds.join(", ")}`
-            : "",
         ]
           .filter(Boolean)
           .join("\n");

package/corpus/core/src/client/agent-chat.ts

@@ -113,6 +113,13 @@ export interface AgentChatContextSetOptions extends AgentChatContextItem {
    * Defaults to true so the user can see the staged context.
    */
   openSidebar?: boolean;
+  /**
+   * Whether to move keyboard focus into the composer when staging the item.
+   * Defaults to true. Pass `false` for context that mirrors ambient UI state
+   * (e.g. a canvas element selection) so staging never steals focus from an
+   * unrelated editor — such as an inline text editor in a design canvas.
+   */
+  focus?: boolean;
 }
 
 /** @deprecated Use `AgentChatContextSetOptions` instead. */
@@ -865,9 +872,17 @@ export function setAgentChatContextItem(
   publishAgentChatContextItems(
     withReplacedAgentChatContextItem(agentChatContextState.items, item),
   );
-  postAgentChatContextMessage(AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE, item, {
-    openSidebar: opts.openSidebar !== false,
-  });
+  // Forward an explicit `focus: false` so the receiving composer can stage the
+  // chip without stealing focus. Focus stays enabled by default (field omitted)
+  // for every existing caller.
+  const messageData = opts.focus === false ? { ...item, focus: false } : item;
+  postAgentChatContextMessage(
+    AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE,
+    messageData,
+    {
+      openSidebar: opts.openSidebar !== false,
+    },
+  );
 }
 
 /** @deprecated Use `setAgentChatContextItem` instead. */

package/corpus/core/src/client/blocks/library/diagram.tsx

@@ -291,7 +291,7 @@ function PositionedDiagram({
               return (
                 <span
                   key={`${edge.from}-${edge.to}-${index}-label`}
-                  className="absolute z-10 max-w-[130px] -translate-x-1/2 -translate-y-1/2 rounded-full border border-border bg-background px-2 py-0.5 text-center text-[11px] font-semibold text-muted-foreground shadow-sm"
+                  className="absolute z-10 max-w-[130px] -translate-x-1/2 -translate-y-1/2 break-words rounded-full border border-border bg-background px-2 py-0.5 text-center text-[11px] font-semibold text-muted-foreground shadow-sm [overflow-wrap:anywhere]"
                   style={{
                     left: `${(from.displayX + to.displayX) / 2}%`,
                     top: `${(from.displayY + to.displayY) / 2}%`,
@@ -305,7 +305,7 @@ function PositionedDiagram({
           {displayNodesForDirection.map((node, index) => (
             <article
               key={node.id}
-              className="absolute z-20 -translate-x-1/2 -translate-y-1/2 rounded-xl border-2 border-border bg-background p-3 text-foreground shadow-sm"
+              className="absolute z-20 -translate-x-1/2 -translate-y-1/2 break-words rounded-xl border-2 border-border bg-background p-3 text-foreground shadow-sm [overflow-wrap:anywhere]"
               style={{
                 left: `${node.displayX}%`,
                 top: `${node.displayY}%`,
@@ -485,7 +485,7 @@ function SequenceDiagram({
               {next && (
                 <div className="grid min-w-[72px] justify-items-center gap-1 text-muted-foreground">
                   {edge?.label && (
-                    <span className="max-w-[96px] truncate rounded-full border border-border px-2 py-0.5 text-[11px] font-semibold">
+                    <span className="max-w-[96px] whitespace-normal break-words rounded-full border border-border px-2 py-0.5 text-center text-[11px] font-semibold [overflow-wrap:anywhere]">
                       {edge.label}
                     </span>
                   )}

package/corpus/core/src/client/chat/message-components.tsx

@@ -784,19 +784,31 @@ function assistantMessageStatusIsTerminal(message: {
   return statusType === "complete" || statusType === "incomplete";
 }
 
+export function assistantMessageHasUnresolvedTool(content: unknown): boolean {
+  if (!Array.isArray(content)) return false;
+  return content.some((part): boolean => {
+    if (!part || typeof part !== "object") return false;
+    const record = part as { type?: unknown; result?: unknown };
+    return record.type === "tool-call" && record.result === undefined;
+  });
+}
+
 export function shouldShowAssistantMessageFooter({
   isLast,
   chatRunning,
   hasRenderableContent,
   statusIsTerminal,
+  hasUnresolvedTool,
 }: {
   isLast: boolean;
   chatRunning: boolean;
   hasRenderableContent: boolean;
   statusIsTerminal: boolean;
+  hasUnresolvedTool?: boolean;
 }): boolean {
   if (!hasRenderableContent) return false;
   if (!isLast) return true;
+  if (hasUnresolvedTool) return false;
   return !chatRunning && statusIsTerminal;
 }
 
@@ -813,11 +825,13 @@ export function AssistantMessage() {
     thread.messages.length > 0 &&
     thread.messages[thread.messages.length - 1].id === msg.id;
   const hasRenderableContent = assistantMessageHasRenderableContent(msg);
+  const hasUnresolvedTool = assistantMessageHasUnresolvedTool(msg.content);
   const isComplete = shouldShowAssistantMessageFooter({
     isLast,
     chatRunning,
     hasRenderableContent,
     statusIsTerminal: assistantMessageStatusIsTerminal(msg),
+    hasUnresolvedTool,
   });
   const cpCtx = React.useContext(CheckpointContext);
 
@@ -907,6 +921,9 @@ export function AssistantMessage() {
         {isComplete && hasCodeAgentTools && msgContent && (
           <FilesChangedSummary parts={msgContent} />
         )}
+        {isLast && hasUnresolvedTool && !chatRunning && (
+          <RunningActivityStatus label="Thinking" />
+        )}
       </div>
       {isComplete && (
         <div className="mt-1 flex items-center justify-between">

package/corpus/core/src/client/use-agent-engine-configured.ts

@@ -35,10 +35,13 @@ async function fetchStatusJson(
     }, timeoutMs);
   });
 
-  const request = fetch(
-    agentNativePath(path),
-    controller ? { signal: controller.signal } : undefined,
-  )
+  // Never serve a stale status from the HTTP cache: this is re-fetched right
+  // after a provider connects, and a cached "missing" would keep the composer
+  // gate and error banner pinned even though a provider is now configured.
+  const request = fetch(agentNativePath(path), {
+    cache: "no-store",
+    ...(controller ? { signal: controller.signal } : {}),
+  })
     .then((r) => (r.ok ? r.json() : null))
     .catch(() => null)
     .finally(() => {

package/corpus/core/src/db/client.ts

@@ -837,13 +837,22 @@ export function neonPoolMax(): number {
  * (agent/durable-background.ts), replicated here to avoid a `db` → `agent`
  * import cycle. Keep the signals in sync with that function.
  */
-function isBackgroundFunctionPoolContext(): boolean {
+export function isBackgroundFunctionPoolContext(): boolean {
   if (
     (globalThis as Record<string, unknown>)
       .__AGENT_NATIVE_BACKGROUND_RUNTIME__ === true
   ) {
     return true;
   }
+  // Set by the HMAC-authenticated agent-chat `_process-run` route before it
+  // re-enters the normal chat handler. This mirrors the marker-only runtime
+  // proof used by durable-background.ts without importing agent code into db/.
+  if (
+    (globalThis as Record<string, unknown>)
+      .__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__ === true
+  ) {
+    return true;
+  }
   const lambdaName = process.env.AWS_LAMBDA_FUNCTION_NAME;
   if (
     typeof lambdaName === "string" &&

package/corpus/core/src/observability/traces.ts

@@ -89,6 +89,14 @@ export async function instrumentAgentLoop(opts: {
    *  reads. */
   userId: string | null;
   config: ObservabilityConfig;
+  classifyError?: (error: unknown) =>
+    | {
+        status?: "success" | "error";
+        errorMessage?: string | null;
+        metadata?: Record<string, unknown> | null;
+      }
+    | null
+    | undefined;
 }): Promise<AgentLoopUsage> {
   const { runAgentLoop, loopOpts, runId, threadId, userId, config } = opts;
   const runStart = Date.now();
@@ -260,11 +268,17 @@ export async function instrumentAgentLoop(opts: {
   let usage: AgentLoopUsage | undefined;
   let runStatus: "success" | "error" = "success";
   let errorMessage: string | null = null;
+  let runMetadata: Record<string, unknown> | null = null;
   try {
     usage = await runAgentLoop({ ...loopOpts, send: instrumentedSend });
   } catch (err: any) {
-    runStatus = "error";
-    errorMessage = err?.message ?? String(err);
+    const classification = opts.classifyError?.(err) ?? null;
+    runStatus = classification?.status ?? "error";
+    errorMessage =
+      classification?.errorMessage === undefined
+        ? (err?.message ?? String(err))
+        : classification.errorMessage;
+    runMetadata = classification?.metadata ?? null;
     throw err;
   } finally {
     const runEnd = Date.now();
@@ -325,7 +339,7 @@ export async function instrumentAgentLoop(opts: {
       durationMs: totalDurationMs,
       status: runStatus,
       errorMessage,
-      metadata: null,
+      metadata: runMetadata,
       createdAt: runStart,
     };
     spans.push(parentSpan);

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -34,8 +34,9 @@ import {
 } from "../agent/app-model-defaults.js";
 import { DEFAULT_ANTHROPIC_MODEL } from "../agent/default-model.js";
 import {
+  AGENT_CHAT_BACKGROUND_RUN_FIELD,
   AGENT_CHAT_PROCESS_RUN_PATH,
-  extractProcessRunId,
+  backgroundRunMarkerExpectsBackgroundRuntime,
   isInBackgroundFunctionRuntime,
   prepareProcessRunRequest,
 } from "../agent/durable-background.js";
@@ -69,6 +70,7 @@ import {
   recordRunDiagnostic,
   RUN_DIAG_STAGE,
   setRunError,
+  setRunTerminalReason,
   updateRunStatusIfRunning,
 } from "../agent/run-store.js";
 import { buildRuntimeContextPrompt } from "../agent/runtime-context.js";
@@ -3876,6 +3878,7 @@ type AgentChatProcessRunFailureDeps = {
   readBackgroundRunClaim?: typeof readBackgroundRunClaim;
   recordRunDiagnostic?: typeof recordRunDiagnostic;
   setRunError?: typeof setRunError;
+  setRunTerminalReason?: typeof setRunTerminalReason;
   updateRunStatusIfRunning?: typeof updateRunStatusIfRunning;
   ensureTerminalRunEvent?: typeof ensureTerminalRunEvent;
 };
@@ -3888,6 +3891,7 @@ export async function finalizeClaimedAgentChatProcessRunFailure(
   const readClaim = deps.readBackgroundRunClaim ?? readBackgroundRunClaim;
   const record = deps.recordRunDiagnostic ?? recordRunDiagnostic;
   const setError = deps.setRunError ?? setRunError;
+  const setTerminalReason = deps.setRunTerminalReason ?? setRunTerminalReason;
   const updateStatus =
     deps.updateRunStatusIfRunning ?? updateRunStatusIfRunning;
   const ensureTerminal = deps.ensureTerminalRunEvent ?? ensureTerminalRunEvent;
@@ -3908,7 +3912,13 @@ export async function finalizeClaimedAgentChatProcessRunFailure(
     CLAIMED_BACKGROUND_WORKER_FAILED_ERROR_EVENT.errorCode,
     `${CLAIMED_BACKGROUND_WORKER_FAILED_ERROR_EVENT.details} setupError=${message}`,
   ).catch(() => {});
-  await updateStatus(runId, "errored").catch(() => {});
+  const statusUpdated = await updateStatus(runId, "errored").catch(() => false);
+  if (statusUpdated) {
+    await setTerminalReason(
+      runId,
+      CLAIMED_BACKGROUND_WORKER_FAILED_ERROR_EVENT.errorCode,
+    ).catch(() => {});
+  }
   await ensureTerminal(
     runId,
     CLAIMED_BACKGROUND_WORKER_FAILED_ERROR_EVENT,
@@ -7400,6 +7410,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
               // unreadable Netlify background-function logs — read
               // `/runs/active?threadId=...` and inspect `diagStage`.
               dispatchMode: run.dispatchMode ?? null,
+              terminalReason: run.terminalReason ?? null,
               diagStage: run.diagStage ?? null,
               workerStage: workerClaim?.workerStage ?? null,
               // Server clock so the client computes "stuck" elapsed time
@@ -7983,18 +7994,6 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             setResponseStatus(event, 405);
             return { error: "Method not allowed" };
           }
-          // DIAGNOSTIC: load the run-store diagnostic recorder. Each stage we
-          // reach is written onto the run row (diag_stage) so a silent failure
-          // INSIDE the Netlify background function — whose logs we cannot read —
-          // is still diagnosable from the client via /runs/active. Best-effort:
-          // the import + every record call is wrapped so diagnostics can never
-          // break the worker path.
-          const diag = await import("../agent/run-store.js")
-            .then((m) => ({
-              record: m.recordRunDiagnostic,
-              stages: m.RUN_DIAG_STAGE,
-            }))
-            .catch(() => null);
 
           // Consume the body ONCE (h3 v2's web Request stream is single-use).
           let processBody: any;
@@ -8005,18 +8004,6 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             return { error: "Invalid request body" };
           }
 
-          // Record "the route handler was entered" against the run BEFORE auth
-          // runs. This is the proof the bg-fn invocation actually reached Nitro
-          // (vs. dying at the function entry / never being invoked). The runId
-          // is parsed without authenticating so we can attach it even on a
-          // subsequent auth failure.
-          const diagRunId = extractProcessRunId(processBody);
-          if (diag && diagRunId) {
-            await diag
-              .record(diagRunId, diag.stages.routeEntered)
-              .catch(() => {});
-          }
-
           // Validate + HMAC-authenticate the self-dispatch and prepare the
           // background-worker body. Pure decision (unit-tested in
           // durable-background.spec.ts); the route only wires it to h3.
@@ -8031,6 +8018,12 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             // bypassing session auth) inside the unreadable bg function would
             // leave the run to time out with NO clue. The detail carries the
             // status + whether A2A_SECRET is even present in this isolate.
+            const diag = await import("../agent/run-store.js")
+              .then((m) => ({
+                record: m.recordRunDiagnostic,
+                stages: m.RUN_DIAG_STAGE,
+              }))
+              .catch(() => null);
             if (diag && prepared.runId) {
               const a2aPresent = Boolean(
                 process.env.A2A_SECRET && process.env.A2A_SECRET.length > 0,
@@ -8047,27 +8040,58 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             return { error: prepared.error };
           }
 
-          // DIAGNOSTIC: auth + body validation passed. Reaching here proves the
-          // request was authenticated and we are about to invoke the worker.
-          if (diag) {
-            await diag
-              .record(prepared.runId, diag.stages.authPassed)
-              .catch(() => {});
+          const preparedMarker = (prepared.body as Record<string, unknown>)[
+            AGENT_CHAT_BACKGROUND_RUN_FIELD
+          ];
+          const expectsBackgroundRuntime =
+            backgroundRunMarkerExpectsBackgroundRuntime(preparedMarker);
+          const runtimeGlobals = globalThis as Record<string, unknown>;
+          const hadExpectedRuntimeMarker = Object.prototype.hasOwnProperty.call(
+            runtimeGlobals,
+            "__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__",
+          );
+          const previousExpectedRuntimeMarker =
+            runtimeGlobals.__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__;
+          if (expectsBackgroundRuntime) {
+            runtimeGlobals.__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__ = true;
           }
 
-          // Stash the verified+augmented body for the handler — the body stream
-          // is already consumed, so the handler reads this instead.
-          (event as any).context = (event as any).context ?? {};
-          (event as any).context.__agentChatBackgroundBody = prepared.body;
-
-          // Durable owner context: this self-dispatch is cookieless (HMAC-only).
-          // Resolve the owner from the persisted run row, never the request body,
-          // then invoke the normal handler. The shared agent-run context helper
-          // expands that owner into the same user/org AsyncLocalStorage context the
-          // foreground request uses, so credential and data scoping stay aligned.
-          await seedBackgroundAgentRunOwnerContext(event, prepared.runId);
-
           try {
+            // DIAGNOSTIC: load the run-store diagnostic recorder only after the
+            // authenticated marker has been mirrored into globalThis. run-store
+            // can initialize the DB pool; the pool must see the same background
+            // proof as the agent timeout logic before that happens.
+            const diag = await import("../agent/run-store.js")
+              .then((m) => ({
+                record: m.recordRunDiagnostic,
+                stages: m.RUN_DIAG_STAGE,
+              }))
+              .catch(() => null);
+
+            // Record "the route handler was entered" against the run after auth
+            // succeeds. This is the proof the bg-fn invocation actually reached
+            // Nitro (vs. dying at the function entry / never being invoked).
+            if (diag) {
+              await diag
+                .record(prepared.runId, diag.stages.routeEntered)
+                .catch(() => {});
+              await diag
+                .record(prepared.runId, diag.stages.authPassed)
+                .catch(() => {});
+            }
+
+            // Stash the verified+augmented body for the handler — the body stream
+            // is already consumed, so the handler reads this instead.
+            (event as any).context = (event as any).context ?? {};
+            (event as any).context.__agentChatBackgroundBody = prepared.body;
+
+            // Durable owner context: this self-dispatch is cookieless (HMAC-only).
+            // Resolve the owner from the persisted run row, never the request
+            // body, then invoke the normal handler. The shared agent-run context
+            // helper expands that owner into the same user/org AsyncLocalStorage
+            // context the foreground request uses, so credential and data scoping
+            // stay aligned.
+            await seedBackgroundAgentRunOwnerContext(event, prepared.runId);
             return await invokeAgentChatHandler(event);
           } catch (err: any) {
             console.error("[agent-chat] _process-run failed:", err);
@@ -8089,6 +8113,18 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
             );
             setResponseStatus(event, 500);
             return { error: "process-run failed" };
+          } finally {
+            if (expectsBackgroundRuntime) {
+              if (hadExpectedRuntimeMarker) {
+                runtimeGlobals.__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__ =
+                  previousExpectedRuntimeMarker;
+              } else {
+                Reflect.deleteProperty(
+                  runtimeGlobals,
+                  "__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__",
+                );
+              }
+            }
           }
         }),
       );

package/corpus/core/src/styles/blocks.css

@@ -1355,8 +1355,37 @@
   color: var(--wf-ink) !important;
 }
 
-.plan-diagram-frame :is(.diagram-node, .diagram-box, .diagram-card) {
+.plan-diagram-frame
+  :is(
+    .diagram-panel,
+    .diagram-card,
+    .diagram-node,
+    .diagram-box,
+    [class*="card"],
+    [class*="panel"],
+    [class*="box"]
+  ) {
   max-width: 100%;
+  overflow-wrap: anywhere !important;
+  word-break: break-word;
+  white-space: normal !important;
+}
+
+.plan-diagram-frame
+  :is(
+    .diagram-panel,
+    .diagram-card,
+    .diagram-node,
+    .diagram-box,
+    [class*="card"],
+    [class*="panel"],
+    [class*="box"]
+  )
+  :is(h1, h2, h3, p, small, strong, span, li) {
+  max-width: 100%;
+  overflow-wrap: anywhere !important;
+  word-break: break-word;
+  white-space: normal !important;
 }
 
 /* Base padding so primitive text never touches the box edge, even when an author
@@ -1422,6 +1451,7 @@
   display: inline-flex;
   align-items: center;
   justify-content: center;
+  flex-wrap: wrap;
   /* A pill hugs its label. `fit-content` is a definite cross size, so a flex
    * column with the default `align-items: stretch` no longer blows the pill out
    * to full width (the number chips and short status labels stay pill-shaped).
@@ -1434,6 +1464,19 @@
   padding: 3px 11px;
   color: var(--wf-ink);
   background: var(--wf-paper);
+  overflow-wrap: anywhere !important;
+  text-align: center;
+  white-space: normal !important;
+  word-break: break-word;
+}
+
+.plan-diagram-frame
+  :is(.diagram-pill, [class*="pill"], [class*="badge"], [class*="chip"])
+  > * {
+  min-width: 0;
+  max-width: 100%;
+  overflow-wrap: anywhere !important;
+  white-space: normal !important;
 }
 
 .plan-diagram-frame :is(.diagram-accent, .diagram-pill.accent) {

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/DashboardFilterBar.tsx

@@ -228,18 +228,25 @@ export function DashboardFilterBar({
       <Collapsible
         open={filtersOpen}
         onOpenChange={setFiltersOpen}
-        className="group rounded-lg border border-border bg-card p-3"
+        className="group rounded-lg border border-border bg-card px-3 py-2"
       >
-        <div className="flex items-center justify-between gap-3">
-          <div className="flex items-baseline gap-2">
-            <h3 className="text-xs font-semibold text-muted-foreground uppercase tracking-wider">
-              {t("sqlDashboard.filters")}
-            </h3>
-            <span className="text-[10px] text-muted-foreground/60">
-              {t("sqlDashboard.autoApplied")}
-            </span>
-          </div>
-          <div className="flex items-center gap-1 opacity-0 transition-opacity focus-within:opacity-100 group-hover:opacity-100 group-data-[state=closed]:opacity-100">
+        <div className="flex flex-wrap items-end justify-between gap-3">
+          <CollapsibleContent className="min-w-0 flex-1">
+            <div className="flex flex-wrap gap-3 items-end">
+              {uniqueFilters.map((f) => (
+                <FilterControl
+                  key={f.id}
+                  filter={f}
+                  vars={vars}
+                  hasParam={(key) =>
+                    searchParams.has(FILTER_PARAM_PREFIX + key)
+                  }
+                  setValue={(updates) => setParam(updates)}
+                />
+              ))}
+            </div>
+          </CollapsibleContent>
+          <div className="flex shrink-0 items-center gap-1 self-center opacity-0 transition-opacity focus-within:opacity-100 group-hover:opacity-100 group-data-[state=closed]:opacity-100">
             {onSaveView && filtersActive && (
               <Button
                 variant="ghost"
@@ -284,19 +291,6 @@ export function DashboardFilterBar({
             </CollapsibleTrigger>
           </div>
         </div>
-        <CollapsibleContent className="pt-3">
-          <div className="flex flex-wrap gap-3 items-end">
-            {uniqueFilters.map((f) => (
-              <FilterControl
-                key={f.id}
-                filter={f}
-                vars={vars}
-                hasParam={(key) => searchParams.has(FILTER_PARAM_PREFIX + key)}
-                setValue={(updates) => setParam(updates)}
-              />
-            ))}
-          </div>
-        </CollapsibleContent>
       </Collapsible>
 
       <Dialog open={saveDialogOpen} onOpenChange={setSaveDialogOpen}>

package/corpus/templates/analytics/changelog/2026-07-01-dashboard-charts-no-longer-show-future-dates-when-clients-se.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-01
+---
+
+Dashboard charts no longer show future dates when clients send bad event timestamps.

package/corpus/templates/analytics/changelog/2026-07-01-dashboard-filters-take-less-space-and-keep-view-actions-tucked.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-01
+---
+
+Dashboard filters take less space and keep view actions tucked to the side.