@zaip-ai/cli 3.3.0 → 3.5.0

package/templates/.agents/dashboard/modules/cost-monitor/src/server/build-cost-summary-projection.ts

@@ -5,19 +5,16 @@ import type {
   UsageProjection,
 } from "@zaip-ai/dashboard-operations/contracts";
 import {
-  canonicalAllTimeDurationMs,
   isAfterLegacyEffortCutoff,
   LEGACY_EFFORT_DAILY_MS,
   LEGACY_EFFORT_SNAPSHOT,
   saoPauloPeriodKey,
 } from "@zaip-ai/dashboard-operations/contracts";
 import {
-  normalizeTokenBackedDailyDuration,
   hybridDailyDuration as sharedHybridDailyDuration,
   rootExecutionDurationByDay as sharedRootExecutionDurationByDay,
 } from "@zaip-ai/dashboard-operations/server";
 import type { CostGroupRow, CostMonitorProjection } from "../contracts.js";
-import { estimatedDurationMs, TOKEN_DURATION_ESTIMATE_BASIS } from "../duration-estimate.js";
 import { buildCostMonitorProjection, usageForRuns } from "./build-cost-monitor-projection.js";
 
 /** Fast Cost Monitor first fold backed only by the durable lifecycle summary. */
@@ -69,9 +66,8 @@ export function buildCostSummaryProjection(
     for (const day of Object.keys(LEGACY_EFFORT_DAILY_MS))
       if (!dailyPeriods.has(day)) dailyPeriods.set(day, emptyPeriodSummary());
   }
-  // Prefer the compact Run projection whenever it is available: it already
-  // assigns the shared effective duration to every tokenized Run. Falling
-  // back to root-only summary timing would turn a tokenized day into 0 s.
+  // Prefer persisted SQLite duration facts; legacy inputs retain their
+  // observed coverage without deriving elapsed time from token volume.
   const periodEntries = [...dailyPeriods].filter(([key]) =>
     inRange(key, operations.filters.from, operations.filters.to),
   );
@@ -105,32 +101,13 @@ export function buildCostSummaryProjection(
     if (hasRunMetrics) return factualDurationByDay.get(key) ?? emptyDuration();
     return dailyDurationSource(key, period);
   };
-  const durationBudget = periodEntries.reduce(
-    (total, [key, period]) => total + durationForDay(key, period).value.known_sum,
-    0,
-  );
-  const normalizedDurationBudget =
-    !hasRunMetrics &&
-    !hasCanonicalSqliteFacts &&
-    operations.filters.from === null &&
-    operations.filters.to === null
-      ? canonicalAllTimeDurationMs(durationBudget)
-      : durationBudget;
   const factualDailyRows = new Map(
     (summary.daily_rows ?? []).map((row) => [row.key, row] as const),
   );
   const projectedDaily = periodEntries.map(([key, period]) =>
     periodRow(key, period, fxRate, durationForDay(key, period), factualDailyRows.get(key)),
   );
-  // Canonical SQLite duration is already deduplicated and assigned to the
-  // correct São Paulo calendar day. Rebalancing it by token population would
-  // preserve only the all-time total while corrupting each daily row.
-  const daily = hasCanonicalSqliteFacts
-    ? projectedDaily
-    : normalizeTokenBackedGroupBudget(
-        projectedDaily.map(ensureTokenBackedGroupDuration),
-        normalizedDurationBudget,
-      );
+  const daily = projectedDaily;
   const runCount = daily.reduce((total, row) => total + row.run_count, 0);
   const eventCount = daily.reduce((total, row) => total + row.event_count, 0);
   // A completely unavailable population must not become a factual zero merely
@@ -199,15 +176,18 @@ export function buildCostSummaryProjection(
       coverage,
     },
     filters_available: {
-      providers: available?.filters_available.providers ?? [],
-      agents: available?.filters_available.agents ?? [],
-      models: available?.filters_available.models ?? [],
-      statuses: available?.filters_available.statuses ?? [],
-      priorities: available?.filters_available.priorities ?? [],
-      risks: available?.filters_available.risks ?? [],
-      phases: available?.filters_available.phases ?? [],
-      origins: available?.filters_available.origins ?? [],
-      work_types: available?.filters_available.work_types ?? [],
+      providers:
+        summary.filters_available?.providers ?? available?.filters_available.providers ?? [],
+      agents: summary.filters_available?.agents ?? available?.filters_available.agents ?? [],
+      models: summary.filters_available?.models ?? available?.filters_available.models ?? [],
+      statuses: summary.filters_available?.statuses ?? available?.filters_available.statuses ?? [],
+      priorities:
+        summary.filters_available?.priorities ?? available?.filters_available.priorities ?? [],
+      risks: summary.filters_available?.risks ?? available?.filters_available.risks ?? [],
+      phases: summary.filters_available?.phases ?? available?.filters_available.phases ?? [],
+      origins: summary.filters_available?.origins ?? available?.filters_available.origins ?? [],
+      work_types:
+        summary.filters_available?.work_types ?? available?.filters_available.work_types ?? [],
     },
     configured_agents: available?.configured_agents ?? [],
     // Compact Run facts preserve total tokens and cost even though component
@@ -240,7 +220,32 @@ export function buildCostSummaryProjection(
 }
 
 function dailyDurationSource(key: string, period: PeriodSummary): DurationSource {
-  return sharedHybridDailyDuration(key, period) as DurationSource;
+  // Preserve the immutable historical aggregate shared with Operations.
+  // This fallback is used only without canonical SQLite or compact Run facts,
+  // and never allocates that historical aggregate to individual tokenized Runs.
+  if ((LEGACY_EFFORT_DAILY_MS[key as keyof typeof LEGACY_EFFORT_DAILY_MS] ?? 0) > 0)
+    return sharedHybridDailyDuration(key, period) as DurationSource;
+  // The legacy period bucket can carry a persisted factual duration. It is
+  // meaningful independently of Run transport and must survive this compact
+  // projection. Tokens and financial usage, however, are never timing data.
+  if (period.duration !== undefined) {
+    const knownRunCount = knownRuns(period.runs, period.duration.unknown);
+    return {
+      value: period.duration,
+      population: runPopulation(period.runs, knownRunCount),
+    };
+  }
+  // A bucket with Runs but no factual duration remains unavailable. In
+  // particular, do not convert a tokenized bucket into an hour or a zero.
+  return {
+    value: {
+      known_sum: 0,
+      unknown: period.runs,
+      complete: period.runs === 0,
+      coverage_ratio: period.runs === 0 ? 1 : 0,
+    },
+    population: runPopulation(period.runs, 0),
+  };
 }
 
 function emptyPeriodSummary(): PeriodSummary {
@@ -258,6 +263,8 @@ function emptyPeriodSummary(): PeriodSummary {
 
 export interface CostSummarySource {
   periods: { daily: Record<string, PeriodSummary> };
+  /** Distinct compact dimensions for first-fold filter controls. */
+  filters_available?: Partial<CostMonitorProjection["filters_available"]>;
   /**
    * SQLite's selected financial facts, retained for compact summaries where
    * no Run transport is present. Values are factual and currency-specific.
@@ -300,7 +307,12 @@ export interface CostSummarySource {
     duration_ms: number | null;
     /** Raw factual invocation duration, never a token estimate. */
     source_duration_ms?: number | null;
-    duration_provenance?: "observed" | "estimated" | "unavailable";
+    duration_provenance?:
+      | "observed"
+      | "reconciled"
+      | "legacy_inferred"
+      | "estimated"
+      | "unavailable";
     estimation_basis?: string | null;
     duration_started_at?: string | null;
     total_tokens: number | null;
@@ -402,63 +414,23 @@ function summaryRunProjection(
 function effectiveSummaryRun(
   run: NonNullable<CostSummarySource["run_metrics"]>[number],
 ): NonNullable<CostSummarySource["run_metrics"]>[number] {
-  if (run.duration_ms !== null)
+  const duration_ms = run.source_duration_ms ?? run.duration_ms;
+  const provenance =
+    run.source_duration_ms !== null && run.source_duration_ms !== undefined
+      ? "observed"
+      : (run.duration_provenance ?? "legacy_inferred");
+  if (
+    typeof duration_ms === "number" &&
+    duration_ms >= 0 &&
+    (provenance === "observed" || provenance === "reconciled" || provenance === "legacy_inferred")
+  )
     return {
       ...run,
-      duration_provenance: run.duration_provenance ?? "unavailable",
-      estimation_basis:
-        run.duration_provenance === "estimated" ? (run.estimation_basis ?? null) : null,
+      duration_ms,
+      duration_provenance: provenance,
+      estimation_basis: null,
     };
-  const duration_ms = estimatedDurationMs(run.total_tokens);
-  return duration_ms === null
-    ? { ...run, duration_provenance: "unavailable", estimation_basis: null }
-    : {
-        ...run,
-        duration_ms,
-        duration_provenance: "estimated",
-        estimation_basis: TOKEN_DURATION_ESTIMATE_BASIS,
-      };
-}
-
-function ensureTokenBackedGroupDuration(row: CostGroupRow): CostGroupRow {
-  if ((row.total_tokens ?? 0) <= 0 || (row.duration_ms ?? 0) > 0) return row;
-  const duration_ms = estimatedDurationMs(row.total_tokens);
-  if (duration_ms === null || duration_ms <= 0) return row;
-  const coverageCounts = row.coverage_counts;
-  return {
-    ...row,
-    duration_ms,
-    duration: { known_sum: duration_ms, unknown: 0, complete: true, coverage_ratio: 1 },
-    ...(coverageCounts === undefined
-      ? {}
-      : {
-          coverage_counts: {
-            ...coverageCounts,
-            ...(coverageCounts.metrics === undefined
-              ? {}
-              : {
-                  metrics: {
-                    ...coverageCounts.metrics,
-                    duration: {
-                      eligible_runs: row.run_count,
-                      known_runs: row.run_count,
-                      unknown_runs: 0,
-                    },
-                  },
-                }),
-          },
-        }),
-  };
-}
-
-function normalizeTokenBackedGroupBudget(
-  rows: readonly CostGroupRow[],
-  budget: number,
-): CostGroupRow[] {
-  return normalizeTokenBackedDailyDuration(rows, budget).map((row) => ({
-    ...row,
-    duration_ms: row.duration.complete ? row.duration.known_sum : null,
-  }));
+  return { ...run, duration_ms: null, duration_provenance: "unavailable", estimation_basis: null };
 }
 
 interface KnownValue {

package/templates/.agents/dashboard/modules/cost-monitor/src/server/cost-monitor-unavailable.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { buildCostMonitorProjection } from "./build-cost-monitor-projection.js";
+import {
+  fxRate,
+  gpt54Catalog,
+  metric,
+  operationsWithPricedRun,
+  usage,
+} from "./build-cost-monitor-projection.test-fixtures.js";
+
+describe("Factual duration and cost", () => {
+  it("retains token-bearing Runs when a cost cannot be established", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (!source) throw new Error("priced Run fixture is missing");
+    operations.runs = [
+      {
+        ...source,
+        id: "RUN-UNKNOWN-MODEL",
+        model: "unknown-model",
+        effective_model: "unknown-model",
+        service_tier: null,
+        usage: usage(metric({ tokens: 1_000, input: 900, cached: 800, output: 100, events: 1 })),
+      },
+      {
+        ...source,
+        id: "RUN-UNKNOWN-TOKENS",
+        model: "gpt-5.4",
+        effective_model: "gpt-5.4",
+        service_tier: null,
+        usage: usage(metric({ tokens: 1_000, input: 900, output: 100, events: 1 })),
+      },
+    ];
+    const projection = buildCostMonitorProjection(operations, {
+      catalog: gpt54Catalog(),
+      fxRate: fxRate(5.5),
+      currency: "BRL",
+    });
+    expect(projection.runs).toHaveLength(2);
+    expect(projection.runs).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          run_id: "RUN-UNKNOWN-MODEL",
+          total_tokens: 1_000,
+          estimated_brl: null,
+        }),
+        expect.objectContaining({
+          run_id: "RUN-UNKNOWN-TOKENS",
+          total_tokens: 1_000,
+          estimated_brl: null,
+        }),
+      ]),
+    );
+  });
+});

package/templates/.agents/dashboard/modules/cost-monitor/src/server/cost-summary-duration.test.ts

@@ -0,0 +1,189 @@
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import { describe, expect, it } from "vitest";
+import {
+  buildCostSummaryProjection,
+  type CostSummarySource,
+} from "./build-cost-summary-projection.js";
+
+describe("Factual duration and cost", () => {
+  it("keeps tokenized compact Runs without factual timing unavailable", () => {
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-07": {
+            prds: 0,
+            specs: 0,
+            tasks: 0,
+            validations: 0,
+            evidences: 0,
+            runs: 1,
+            usage: {
+              total_tokens: { known_sum: 4_000_000, unknown: 0, complete: true, coverage_ratio: 1 },
+              cost: {
+                known_sum: 1,
+                unknown: 0,
+                complete: true,
+                coverage_ratio: 1,
+                currency: "BRL",
+              },
+            },
+          },
+        },
+      },
+      run_metrics: [
+        {
+          id: "TOKEN-ONLY",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: null,
+          total_tokens: 4_000_000,
+          cost: 1,
+          currency: "BRL",
+          events: 1,
+        },
+      ],
+    };
+    const operations = {
+      filters: { from: "2026-08-07", to: "2026-08-07" },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
+    expect(projection.groups.daily[0]?.duration).toMatchObject({
+      known_sum: 0,
+      unknown: 1,
+      complete: false,
+    });
+    expect(projection.groups.daily[0]?.duration_ms).toBeNull();
+  });
+
+  it("keeps a tokenized legacy period without factual duration unavailable", () => {
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-07": {
+            prds: 0,
+            specs: 0,
+            tasks: 0,
+            validations: 0,
+            evidences: 0,
+            runs: 1,
+            usage: {
+              total_tokens: { known_sum: 4_000_000, unknown: 0, complete: true, coverage_ratio: 1 },
+              cost: {
+                known_sum: 1,
+                unknown: 0,
+                complete: true,
+                coverage_ratio: 1,
+                currency: "BRL",
+              },
+            },
+          },
+        },
+      },
+    };
+    const operations = {
+      filters: { from: "2026-08-07", to: "2026-08-07" },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
+    expect(projection.groups.daily[0]).toMatchObject({
+      total_tokens: 4_000_000,
+      duration_ms: null,
+      duration: { known_sum: 0, unknown: 1, complete: false },
+    });
+  });
+
+  it("uses the canonical root duration and excludes child and conversation duration", () => {
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-07-24": {
+            prds: 0,
+            specs: 0,
+            tasks: 0,
+            validations: 0,
+            evidences: 0,
+            runs: 3,
+            usage: {
+              total_tokens: { known_sum: 3, unknown: 0, complete: true, coverage_ratio: 1 },
+              cost: {
+                known_sum: 3,
+                unknown: 0,
+                complete: true,
+                coverage_ratio: 1,
+                currency: "BRL",
+              },
+            },
+            duration: { known_sum: 60_109_200, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+        },
+      },
+      run_metrics: [
+        {
+          id: "ROOT",
+          started_at: "2026-07-24T20:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 23_241_600,
+          total_tokens: 1,
+          cost: 1,
+          currency: "BRL",
+          events: 1,
+        },
+        {
+          id: "CHILD",
+          started_at: "2026-07-24T20:01:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: "ROOT",
+          status: null,
+          duration_ms: 36_867_600,
+          total_tokens: 1,
+          cost: 1,
+          currency: "BRL",
+          events: 1,
+        },
+        {
+          id: "CONVERSATION",
+          started_at: "2026-07-24T20:02:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "conversation",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 1_000,
+          total_tokens: 1,
+          cost: 1,
+          currency: "BRL",
+          events: 1,
+        },
+      ],
+      canonical_daily_duration_ms: { "2026-07-24": 23_241_600 },
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    const row = buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily.find(
+      (value) => value.key === "2026-07-24",
+    )!;
+
+    expect(row.duration.known_sum).toBe(23_241_600);
+    expect(row.duration.coverage_ratio).toBe(1);
+    expect(row.run_count).toBe(3);
+  });
+});

package/templates/.agents/dashboard/modules/operations/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/dashboard-operations",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "private": true,
   "type": "module",
   "exports": {

package/templates/.agents/dashboard/modules/operations/src/react/OperationsEntityFilters.tsx

@@ -0,0 +1,82 @@
+import type { OperationsLocale } from "./status-labels.js";
+import { riskLabel } from "./status-labels.js";
+import { taskOriginLabel, taskOriginOptions, type TaskOrigin } from "./task-origin.js";
+import { workStageLabel, workStages } from "./work-board-model.js";
+
+/** Work filters belong to the visible shared header, not the retired hero. */
+export function OperationsEntityFilters({
+  locale,
+  query,
+  status,
+  risk,
+  origin,
+  onQuery,
+  onStatus,
+  onRisk,
+  onOrigin,
+}: {
+  locale: OperationsLocale;
+  query: string;
+  status: string;
+  risk: string;
+  origin: TaskOrigin | "";
+  onQuery: (value: string) => void;
+  onStatus: (value: string) => void;
+  onRisk: (value: string) => void;
+  onOrigin: (value: TaskOrigin | "") => void;
+}) {
+  const all = locale === "pt-BR" ? "Todos" : "All";
+  return (
+    <div className="operations-entity-filters">
+      <label>
+        <span>{locale === "pt-BR" ? "Busca" : "Search"}</span>
+        <input
+          aria-label={locale === "pt-BR" ? "Busca" : "Search"}
+          value={query}
+          onChange={(e) => onQuery(e.target.value)}
+        />
+      </label>
+      <label>
+        <span>Status</span>
+        <select aria-label="Status" value={status} onChange={(e) => onStatus(e.target.value)}>
+          <option value="">{all}</option>
+          {workStages.map((stage) => (
+            <option key={stage} value={stage}>
+              {workStageLabel(stage, locale)}
+            </option>
+          ))}
+        </select>
+      </label>
+      <label>
+        <span>{locale === "pt-BR" ? "Risco" : "Risk"}</span>
+        <select
+          aria-label={locale === "pt-BR" ? "Risco" : "Risk"}
+          value={risk}
+          onChange={(e) => onRisk(e.target.value)}
+        >
+          <option value="">{all}</option>
+          {["lite", "standard", "critical"].map((value) => (
+            <option key={value} value={value}>
+              {riskLabel(value, locale)}
+            </option>
+          ))}
+        </select>
+      </label>
+      <label>
+        <span>{locale === "pt-BR" ? "Origem" : "Origin"}</span>
+        <select
+          aria-label={locale === "pt-BR" ? "Origem" : "Origin"}
+          value={origin}
+          onChange={(e) => onOrigin(e.target.value as TaskOrigin | "")}
+        >
+          <option value="">{all}</option>
+          {taskOriginOptions.map((value) => (
+            <option key={value} value={value}>
+              {taskOriginLabel(value)}
+            </option>
+          ))}
+        </select>
+      </label>
+    </div>
+  );
+}

package/templates/.agents/dashboard/modules/operations/src/react/OperationsPage.tsx

@@ -2,6 +2,7 @@ import { DashboardHeader } from "@zaip-ai/dashboard-ui";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { ExcelExportAction } from "./export/ExcelExportAction.js";
 import { OperationDateFilters } from "./OperationDateFilters.js";
+import { OperationsEntityFilters } from "./OperationsEntityFilters.js";
 import {
   ChevronDownIcon,
   FilterIcon,
@@ -17,6 +18,7 @@ import {
   resolveOperationsPeriodControl,
   workListTypeOnViewChange,
 } from "./operations-page-contract.js";
+import { useOperationFilterFeedback } from "./use-operation-filter-feedback.js";
 
 export {
   type DashboardGlobalFilters,
@@ -33,17 +35,16 @@ import {
   type OperationDatePreset,
   type OperationDateRange,
 } from "./operation-date-range.js";
+import { factualDurationRowsForExport } from "./operations-export-duration.js";
 import type { OperationsView } from "./operations-page-filters.js";
 import { macrosWithPeriodActivity } from "./operations-period-scope.js";
 import { matchesQuery } from "./operations-query.js";
 import { viewLabels } from "./operations-view-labels.js";
-import { applyFactualPeriodCosts, applyFactualPeriodDurations } from "./PeriodSummaryTable.js";
-import {
-  aggregateManifestPeriodSummary,
-  aggregatePeriodSummary,
-  type PeriodGranularity,
-  type PeriodSummaryRow,
-} from "./period-summary.js";
+import { applyFactualPeriodCosts } from "./PeriodSummaryTable.js";
+
+export { factualDurationRowsForExport } from "./operations-export-duration.js";
+
+import { aggregateManifestPeriodSummary, aggregatePeriodSummary } from "./period-summary.js";
 import { periodSummaryPopulation } from "./period-summary-population.js";
 import { scopeRunsToEntities } from "./run-scope.js";
 import { riskLabel } from "./status-labels.js";
@@ -66,17 +67,6 @@ import "./operations-date-filters.css";
 import "./operations-filter-panel.css";
 import "./operations-responsive.css";
 
-/** Applies Cost Monitor duration facts only to the Operations period exports that share them. */
-export function factualDurationRowsForExport(
-  granularity: PeriodGranularity,
-  rows: readonly PeriodSummaryRow[],
-  factualRows?: readonly { key: string; duration_ms: number | null }[],
-): PeriodSummaryRow[] {
-  return granularity === "month" || granularity === "year"
-    ? applyFactualPeriodDurations(rows, factualRows)
-    : [...rows];
-}
-
 export function OperationsPage({
   alternateContent,
   boardTotals,
@@ -130,8 +120,7 @@ export function OperationsPage({
   const [statusFilter, setStatusFilter] = useState("");
   const [riskFilter, setRiskFilter] = useState("");
   const [originFilter, setOriginFilter] = useState<TaskOrigin | "">("");
-  const [filterLoading, setFilterLoading] = useState(false);
-  const filterLoadingTimer = useRef<number | null>(null);
+  const { filterLoading, showFilterLoading } = useOperationFilterFeedback();
   const searchInputRef = useRef<HTMLInputElement>(null);
   const defaultDateRange = useMemo(() => {
     const operationsRange = initialOperationsDateRange(
@@ -165,17 +154,6 @@ export function OperationsPage({
   );
   // Coverage is derived display data, not a user selection. Never feed it
   // back through onDateChange: a delayed effect can overwrite a newer period.
-  const showFilterLoading = useCallback(() => {
-    setFilterLoading(true);
-    if (filterLoadingTimer.current !== null) window.clearTimeout(filterLoadingTimer.current);
-    filterLoadingTimer.current = window.setTimeout(() => setFilterLoading(false), 220);
-  }, []);
-  useEffect(
-    () => () => {
-      if (filterLoadingTimer.current !== null) window.clearTimeout(filterLoadingTimer.current);
-    },
-    [],
-  );
   const renderedAlternateContent =
     typeof alternateContent === "function"
       ? alternateContent({ query, datePreset, ...(datePreset === "all" ? {} : { dateRange }) })
@@ -467,6 +445,19 @@ export function OperationsPage({
                 </span>
               ) : null}
             </div>
+            {!renderedAlternateContent ? (
+              <OperationsEntityFilters
+                locale={locale}
+                query={query}
+                status={statusFilter}
+                risk={riskFilter}
+                origin={originFilter}
+                onQuery={setQuery}
+                onStatus={setStatusFilter}
+                onRisk={setRiskFilter}
+                onOrigin={setOriginFilter}
+              />
+            ) : null}
             <OperationDateFilters
               ariaLabelSuffix={locale === "pt-BR" ? " nos filtros" : " in filters"}
               dateRange={dateRange}