fix(queries): close six stale-data gaps found auditing the query layer

Each was verified against the mutation that changes the data and the keys that
expose it, not taken on report.

- Workspace usage/credits were invalidated nowhere in the app. Six sites already
  refreshed subscriptionKeys after credits moved — post-run, post-wand, limit
  edits, upgrades, top-ups — and none touched workspace usage, so the credits
  chip and the run gate held their page-load values until a reload. Adds one
  shared invalidateWorkspaceUsage and calls it from all six.
- Knowledge-base list doc counts went stale: document upload, delete, and bulk
  delete invalidated only the detail key, though the list carries docCount.
- Plan switches that do not redirect refreshed only the host context, leaving
  subscription and credit state showing the previous plan.
- The copilot tool-event handler invalidated a raw workflowKeys.list, which
  covers only the active scope and skips the selector prefix; it now uses the
  shared invalidateWorkflowLists like the other thirteen call sites.
- scheduleKeys.byId was a strict prefix of scheduleKeys.schedule, so the two
  addressings aliased, and nothing invalidated byId. De-aliased and invalidated.

Not changed: the CSV preview key already folds in the file version and storage
key, so a content update addresses a different cache entry — version-in-key is
the mechanism there, not a missing invalidation.

Tests added for the usage and knowledge fixes, both proven to fail without them.
The other four live in files that cannot load in a git worktree (pre-existing
postcss resolution failure), so CI is where they first run.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts

@@ -27,7 +27,7 @@ import {
 } from '@/app/workspace/[workspaceId]/home/hooks/stream/turn-model'
 import { deploymentKeys } from '@/hooks/queries/deployments'
 import { folderKeys } from '@/hooks/queries/utils/folder-keys'
-import { workflowKeys } from '@/hooks/queries/workflows'
+import { invalidateWorkflowLists } from '@/hooks/queries/utils/invalidate-workflow-lists'
 
 type ToolEvent = Extract<PersistedStreamEventEnvelope, { type: 'tool' }>
 
@@ -58,15 +58,17 @@ function runToolResultSideEffects(ctx: StreamLoopContext, node: ToolNode): void
     if (deployedWorkflowId && typeof out?.isDeployed === 'boolean') {
       deps.queryClient.invalidateQueries({ queryKey: deploymentKeys.info(deployedWorkflowId) })
       deps.queryClient.invalidateQueries({ queryKey: deploymentKeys.versions(deployedWorkflowId) })
-      deps.queryClient.invalidateQueries({ queryKey: workflowKeys.list(deps.workspaceId) })
+      void invalidateWorkflowLists(deps.queryClient, deps.workspaceId)
     }
   }
 
   if (FOLDER_TOOL_NAMES.has(name) && isSuccess) {
     deps.queryClient.invalidateQueries({ queryKey: folderKeys.list(deps.workspaceId) })
   }
   if (WORKFLOW_MUTATION_TOOL_NAMES.has(name) && isSuccess) {
-    deps.queryClient.invalidateQueries({ queryKey: workflowKeys.list(deps.workspaceId) })
+    // `rm` archives, so the archived list moves too — and the shared helper also
+    // refreshes the workflow selector lists that `@`-mentions and pickers read.
+    void invalidateWorkflowLists(deps.queryClient, deps.workspaceId, ['active', 'archived'])
   }
 
   const extractedResources =

apps/sim/app/workspace/[workspaceId]/knowledge/hooks/use-knowledge-upload.ts

@@ -209,7 +209,11 @@ export function useKnowledgeUpload(options: UseKnowledgeUploadOptions = {}) {
       setUploadProgress((prev) => ({ ...prev, stage: 'processing' }))
       logger.info(`Successfully started processing ${uploadedDocuments.length} documents`)
 
-      await queryClient.invalidateQueries({ queryKey: knowledgeKeys.detail(knowledgeBaseId) })
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: knowledgeKeys.detail(knowledgeBaseId) }),
+        /** The knowledge-base list rows carry `docCount`, so an upload changes them too. */
+        queryClient.invalidateQueries({ queryKey: knowledgeKeys.lists() }),
+      ])
 
       return uploadedDocuments
     } catch (err) {

apps/sim/app/workspace/[workspaceId]/upgrade/hooks/use-upgrade-state.ts

@@ -9,7 +9,9 @@ import type { WorkspaceHostContext } from '@/lib/api/contracts/workspaces'
 import { useSubscriptionUpgrade } from '@/lib/billing/client/upgrade'
 import { CREDIT_TIERS } from '@/lib/billing/constants'
 import { getPlanTierCredits, isEnterprise, isFree, isPro, isTeam } from '@/lib/billing/plan-helpers'
+import { subscriptionKeys } from '@/hooks/queries/subscription'
 import { workspaceHostKeys } from '@/hooks/queries/workspace-host'
+import { invalidateWorkspaceUsage } from '@/hooks/queries/workspace-usage'
 
 const PRO_TIER = CREDIT_TIERS[0]
 const MAX_TIER = CREDIT_TIERS[1]
@@ -89,8 +91,20 @@ export function useUpgradeState({
     }
   }, [ownerBilling.billingInterval, subscription.isPaid])
 
-  const refreshHostContext = useCallback(
-    () => queryClient.invalidateQueries({ queryKey: workspaceHostKeys.detail(workspaceId) }),
+  /**
+   * A non-redirect plan switch settles server-side immediately, so every read that
+   * describes the plan has to be refetched — the host context the page renders from,
+   * the subscription/usage reads the billing surfaces share, and the workspace credit
+   * availability that drives the credits chip and the run gate.
+   */
+  const refreshBillingState = useCallback(
+    () =>
+      Promise.all([
+        queryClient.invalidateQueries({ queryKey: workspaceHostKeys.detail(workspaceId) }),
+        queryClient.invalidateQueries({ queryKey: subscriptionKeys.users() }),
+        queryClient.invalidateQueries({ queryKey: subscriptionKeys.usage() }),
+        invalidateWorkspaceUsage(queryClient),
+      ]),
     [queryClient, workspaceId]
   )
 
@@ -123,9 +137,9 @@ export function useUpgradeState({
       await requestJson(billingSwitchPlanContract, {
         body: { targetPlanName: subscription.plan, interval, workspaceId },
       })
-      await refreshHostContext()
+      await refreshBillingState()
     },
-    [isLegacyPlan, refreshHostContext, subscription.plan, workspaceId]
+    [isLegacyPlan, refreshBillingState, subscription.plan, workspaceId]
   )
 
   const currentCredits = getPlanTierCredits(subscription.plan)
@@ -154,11 +168,11 @@ export function useUpgradeState({
           workspaceId,
         },
       })
-      await refreshHostContext()
+      await refreshBillingState()
     } catch (e) {
       toast.error(getErrorMessage(e, 'Failed to upgrade'))
     }
-  }, [subscription.isTeam, isAnnual, refreshHostContext, workspaceId])
+  }, [subscription.isTeam, isAnnual, refreshBillingState, workspaceId])
 
   const onUpgradeToOtherTier = useCallback(async () => {
     const onMax =
@@ -170,11 +184,11 @@ export function useUpgradeState({
       await requestJson(billingSwitchPlanContract, {
         body: { targetPlanName, workspaceId },
       })
-      await refreshHostContext()
+      await refreshBillingState()
     } catch (e) {
       toast.error(getErrorMessage(e, 'Failed to switch plan'))
     }
-  }, [subscription.plan, subscription.isTeam, refreshHostContext, workspaceId])
+  }, [subscription.plan, subscription.isTeam, refreshBillingState, workspaceId])
 
   return {
     isLoading: false,

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-wand.ts

@@ -11,6 +11,7 @@ import { readSSEStream } from '@/lib/core/utils/sse'
 import { shouldStripCodeFences, stripCodeFences } from '@/lib/wand/strip-code-fences'
 import type { GenerationType } from '@/blocks/types'
 import { subscriptionKeys } from '@/hooks/queries/subscription'
+import { invalidateWorkspaceUsage } from '@/hooks/queries/workspace-usage'
 import { useSettingsNavigation } from '@/hooks/use-settings-navigation'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 
@@ -302,6 +303,7 @@ export function useWand({
 
         setTimeout(() => {
           queryClient.invalidateQueries({ queryKey: subscriptionKeys.users() })
+          void invalidateWorkspaceUsage(queryClient)
         }, 1000)
       } catch (error: any) {
         if (error.name === 'AbortError') {

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.ts

@@ -63,6 +63,7 @@ import { hasExecutionResult } from '@/executor/utils/errors'
 import { coerceValue } from '@/executor/utils/start-block'
 import { subscriptionKeys } from '@/hooks/queries/subscription'
 import { getWorkflows } from '@/hooks/queries/utils/workflow-cache'
+import { invalidateWorkspaceUsage } from '@/hooks/queries/workspace-usage'
 import {
   isExecutionStreamHttpError,
   SSEEventHandlerError,
@@ -924,6 +925,7 @@ export function useWorkflowExecution() {
                 // Invalidate subscription queries to update usage
                 setTimeout(() => {
                   queryClient.invalidateQueries({ queryKey: subscriptionKeys.users() })
+                  void invalidateWorkspaceUsage(queryClient)
                 }, 1000)
 
                 safeEnqueue(encodeSSE({ event: 'final', data: result }))
@@ -1460,6 +1462,7 @@ export function useWorkflowExecution() {
                 }
                 setTimeout(() => {
                   queryClient.invalidateQueries({ queryKey: subscriptionKeys.users() })
+                  void invalidateWorkspaceUsage(queryClient)
                 }, 1000)
               }
             },

apps/sim/hooks/queries/kb/knowledge.test.ts

@@ -0,0 +1,75 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  requestJson: vi.fn(),
+  useMutation: vi.fn(),
+  invalidateQueries: vi.fn(),
+}))
+
+vi.mock('@tanstack/react-query', () => ({
+  keepPreviousData: Symbol('keepPreviousData'),
+  useInfiniteQuery: vi.fn(),
+  useMutation: mocks.useMutation,
+  useQuery: vi.fn(),
+  useQueryClient: vi.fn(() => ({ invalidateQueries: mocks.invalidateQueries })),
+}))
+
+vi.mock('@sim/emcn', () => ({
+  toast: { error: vi.fn(), success: vi.fn() },
+}))
+
+vi.mock('@/lib/api/client/request', () => ({
+  requestJson: mocks.requestJson,
+}))
+
+import { useBulkDocumentOperation, useDeleteDocument } from '@/hooks/queries/kb/knowledge'
+import { knowledgeKeys } from '@/hooks/queries/utils/knowledge-keys'
+
+interface CapturedMutation {
+  onSettled: (data: unknown, error: unknown, variables: Record<string, unknown>) => void
+}
+
+function captureMutation(build: () => unknown): CapturedMutation {
+  let captured: CapturedMutation | undefined
+  mocks.useMutation.mockImplementation((options: CapturedMutation) => {
+    captured = options
+    return {}
+  })
+  build()
+  if (!captured) throw new Error('useMutation was not called')
+  return captured
+}
+
+describe('knowledge document mutations', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('invalidates the knowledge-base lists when a document is deleted', () => {
+    const mutation = captureMutation(() => useDeleteDocument())
+
+    mutation.onSettled(undefined, undefined, { knowledgeBaseId: 'kb-1', documentId: 'doc-1' })
+
+    expect(mocks.invalidateQueries).toHaveBeenCalledWith({ queryKey: knowledgeKeys.lists() })
+  })
+
+  it('invalidates the knowledge-base lists on a bulk delete', () => {
+    const mutation = captureMutation(() => useBulkDocumentOperation())
+
+    mutation.onSettled(undefined, undefined, { knowledgeBaseId: 'kb-1', operation: 'delete' })
+
+    expect(mocks.invalidateQueries).toHaveBeenCalledWith({ queryKey: knowledgeKeys.lists() })
+  })
+
+  it('leaves the knowledge-base lists alone on a bulk enable', () => {
+    const mutation = captureMutation(() => useBulkDocumentOperation())
+
+    mutation.onSettled(undefined, undefined, { knowledgeBaseId: 'kb-1', operation: 'enable' })
+
+    expect(mocks.invalidateQueries).not.toHaveBeenCalledWith({ queryKey: knowledgeKeys.lists() })
+  })
+})

apps/sim/hooks/queries/kb/knowledge.ts

@@ -539,6 +539,10 @@ export function useDeleteDocument() {
       queryClient.invalidateQueries({
         queryKey: knowledgeKeys.detail(knowledgeBaseId),
       })
+      /** The knowledge-base list rows carry `docCount`, so removing a document changes them too. */
+      queryClient.invalidateQueries({
+        queryKey: knowledgeKeys.lists(),
+      })
     },
   })
 }
@@ -573,10 +577,16 @@ export function useBulkDocumentOperation() {
 
   return useMutation({
     mutationFn: bulkDocumentOperation,
-    onSettled: (_data, _error, { knowledgeBaseId }) => {
+    onSettled: (_data, _error, { knowledgeBaseId, operation }) => {
       queryClient.invalidateQueries({
         queryKey: knowledgeKeys.detail(knowledgeBaseId),
       })
+      /** Only a bulk delete changes the `docCount` the knowledge-base list rows render. */
+      if (operation === 'delete') {
+        queryClient.invalidateQueries({
+          queryKey: knowledgeKeys.lists(),
+        })
+      }
     },
   })
 }

apps/sim/hooks/queries/schedules.ts

@@ -27,7 +27,13 @@ export const scheduleKeys = {
   details: () => [...scheduleKeys.all, 'detail'] as const,
   schedule: (workflowId: string, blockId: string) =>
     [...scheduleKeys.details(), workflowId, blockId] as const,
-  byId: (scheduleId: string) => [...scheduleKeys.details(), scheduleId] as const,
+  /**
+   * By-id reads sit under their own segment rather than directly under `details()`:
+   * a bare `[...details(), scheduleId]` is a prefix of `schedule(scheduleId, blockId)`,
+   * so the two addressings of the same schedule would alias in the cache.
+   */
+  byIds: () => [...scheduleKeys.details(), 'by-id'] as const,
+  byId: (scheduleId: string) => [...scheduleKeys.byIds(), scheduleId] as const,
 }
 
 export type ScheduleData = WorkflowScheduleRow
@@ -196,7 +202,7 @@ export function useReactivateSchedule() {
         body: { action: 'reactivate' },
       })
 
-      return { workflowId, blockId, workspaceId }
+      return { scheduleId, workflowId, blockId, workspaceId }
     },
     onSuccess: ({ workflowId, blockId }) => {
       logger.info('Schedule reactivated', { workflowId, blockId })
@@ -206,9 +212,10 @@ export function useReactivateSchedule() {
     },
     onSettled: async (data) => {
       if (!data) return
-      const { workflowId, blockId, workspaceId } = data
+      const { scheduleId, workflowId, blockId, workspaceId } = data
       await Promise.all([
         queryClient.invalidateQueries({ queryKey: scheduleKeys.schedule(workflowId, blockId) }),
+        queryClient.invalidateQueries({ queryKey: scheduleKeys.byId(scheduleId) }),
         workspaceId
           ? queryClient.invalidateQueries({ queryKey: scheduleKeys.list(workspaceId) })
           : Promise.resolve(),

apps/sim/hooks/queries/subscription.ts

@@ -14,6 +14,7 @@ import {
 } from '@/lib/api/contracts/subscription'
 import { organizationKeys } from '@/hooks/queries/organization'
 import { workspaceKeys } from '@/hooks/queries/workspace'
+import { invalidateWorkspaceUsage } from '@/hooks/queries/workspace-usage'
 
 export type { SubscriptionApiResponse }
 
@@ -265,6 +266,7 @@ export function useUpdateUsageLimit() {
       return Promise.all([
         queryClient.invalidateQueries({ queryKey: subscriptionKeys.users() }),
         queryClient.invalidateQueries({ queryKey: subscriptionKeys.usage() }),
+        invalidateWorkspaceUsage(queryClient),
       ])
     },
   })
@@ -291,6 +293,7 @@ export function useUpgradeSubscription() {
         queryClient.invalidateQueries({ queryKey: subscriptionKeys.usage() }),
         queryClient.invalidateQueries({ queryKey: subscriptionKeys.invoicesAll() }),
         queryClient.invalidateQueries({ queryKey: workspaceKeys.lists() }),
+        invalidateWorkspaceUsage(queryClient),
         ...(variables.orgId
           ? [
               queryClient.invalidateQueries({
@@ -328,6 +331,7 @@ export function usePurchaseCredits() {
       return Promise.all([
         queryClient.invalidateQueries({ queryKey: subscriptionKeys.users() }),
         queryClient.invalidateQueries({ queryKey: subscriptionKeys.usage() }),
+        invalidateWorkspaceUsage(queryClient),
         ...(variables.orgId
           ? [
               queryClient.invalidateQueries({

apps/sim/hooks/queries/workspace-usage.test.ts

@@ -18,6 +18,7 @@ import {
 import {
   fetchWorkspaceCreditAvailability,
   fetchWorkspaceUsageGate,
+  invalidateWorkspaceUsage,
   WORKSPACE_CREDIT_AVAILABILITY_STALE_TIME,
   WORKSPACE_USAGE_GATE_STALE_TIME,
   workspaceUsageKeys,
@@ -65,4 +66,18 @@ describe('workspace usage gate query', () => {
       signal,
     })
   })
+
+  it('invalidates both usage families so a spend or top-up refetches them', async () => {
+    const invalidateQueries = vi.fn().mockResolvedValue(undefined)
+    const queryClient = { invalidateQueries } as unknown as Parameters<
+      typeof invalidateWorkspaceUsage
+    >[0]
+
+    await invalidateWorkspaceUsage(queryClient)
+
+    expect(invalidateQueries).toHaveBeenCalledWith({
+      queryKey: workspaceUsageKeys.creditAvailabilities(),
+    })
+    expect(invalidateQueries).toHaveBeenCalledWith({ queryKey: workspaceUsageKeys.gates() })
+  })
 })