fix(deploy): derive every deploy surface from one deployment verdict

The modal could render "Deploy your workflow to see a preview" directly above a
version row reading `v1 (live)`, because the General tab inferred "not deployed"
from the ABSENCE OF A SNAPSHOT. A missing snapshot is not evidence of anything —
usually it just has not arrived — and treating it as evidence let the modal
contradict itself.

Underneath that, nothing re-fetched the snapshot once it came back empty.
`refetchDeploymentBoundary` fires while the query is still disabled (it is gated
on `isDeployed`, which is not true yet), and a disabled query cannot be
refetched, so a null cached during the activation window survived the whole
stale period. `useDeployedWorkflowState` now retries while it holds no snapshot
and stops the instant one arrives — the query is only enabled once the workflow
IS deployed, so a null there is a contradiction to resolve, not an answer.

The deeper problem was that the chip, the modal footer and the preview each
derived their own verdict from a different mix of raw flags. That is the same
failure this branch fixes one layer down — several derivations of one fact,
drifting — so it gets the same treatment. `useDeploymentViewState` derives once;
the chip, the modal and the General tab consume it and are given no raw material
to re-derive from. `DeployModal` now takes one `deployment` prop in place of
four booleans it used to recombine.

Also brings the chip in line with the busy-label pattern every sibling control
on this surface already follows (`{isUndeploying ? 'Undeploying...' : 'Undeploy'}`
in the modal footer): it now reads "Deploying..." while the deploy is in flight,
where before it announced nothing and merely went disabled. Scoped to the deploy
action, which the mutation bounds. The readiness states stay in the tooltip on
purpose — `saving` fires on every settled keystroke, so putting it on the chip
would reintroduce the label churn the state machine exists to remove.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/components/deploy-modal/components/general/general.tsx

@@ -33,6 +33,8 @@ interface GeneralDeployProps {
   workflowId: string | null
   deployedState?: WorkflowState | null
   isLoadingDeployedState: boolean
+  /** A snapshot is expected but has not arrived — render loading, not "undeployed". */
+  isAwaitingSnapshot: boolean
   versions: WorkflowDeploymentVersionResponse[]
   versionsLoading: boolean
   isPromotingVersion: boolean
@@ -51,6 +53,7 @@ export function GeneralDeploy({
   workflowId,
   deployedState,
   isLoadingDeployedState,
+  isAwaitingSnapshot,
   versions,
   versionsLoading,
   isPromotingVersion,
@@ -169,7 +172,13 @@ export function GeneralDeploy({
   const showToggle = selectedVersion !== null && deployedState
 
   const hasDeployedData = deployedState && Object.keys(deployedState.blocks || {}).length > 0
-  const showLoadingSkeleton = isLoadingDeployedState && !hasDeployedData
+  /*
+   * `isAwaitingSnapshot` counts as loading. A missing snapshot is not evidence
+   * that the workflow is undeployed — it is usually the snapshot not having
+   * arrived yet — and treating it as evidence is what rendered "Deploy your
+   * workflow to see a preview" directly above a row reading `v1 (live)`.
+   */
+  const showLoadingSkeleton = (isLoadingDeployedState || isAwaitingSnapshot) && !hasDeployedData
 
   if (showLoadingSkeleton) {
     return (

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/components/deploy-modal/deploy-modal.tsx

@@ -35,6 +35,7 @@ import {
   tryAcquireDeployAction,
 } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/deploy-action-lock'
 import type { DeployReadiness } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-deploy-readiness'
+import type { DeploymentViewState } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-deployment-view-state'
 import { runPreDeployChecks } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-predeploy-checks'
 import { normalizeName, startsWithUuid } from '@/executor/constants'
 import { useApiKeys } from '@/hooks/queries/api-keys'
@@ -66,12 +67,10 @@ interface DeployModalProps {
   open: boolean
   onOpenChange: (open: boolean) => void
   workflowId: string | null
-  isDeployed: boolean
-  needsRedeployment: boolean
+  /** The one derived deployment verdict, shared with the deploy chip. */
+  deployment: DeploymentViewState
   deployedState?: WorkflowState | null
-  isLoadingDeployedState: boolean
   deployReadiness: DeployReadiness
-  isDeploymentSettling: boolean
 }
 
 interface WorkflowDeploymentInfoUI {
@@ -96,13 +95,19 @@ export function DeployModal({
   open,
   onOpenChange,
   workflowId,
-  isDeployed: isDeployedProp,
-  needsRedeployment,
-  deployedState,
-  isLoadingDeployedState,
+  deployment,
   deployReadiness,
-  isDeploymentSettling,
 }: DeployModalProps) {
+  const {
+    status: deploymentStatus,
+    isDeployed: isDeployedProp,
+    deployedState,
+    isAwaitingSnapshot,
+    isSettling: isDeploymentSettling,
+  } = deployment
+  const needsRedeployment = deploymentStatus === 'changed'
+  /* A snapshot that is expected but absent reads as loading everywhere. */
+  const isLoadingDeployedState = isAwaitingSnapshot
   const queryClient = useQueryClient()
   const params = useParams()
   const workspaceId = params?.workspaceId as string
@@ -561,6 +566,7 @@ export function DeployModal({
                   workflowId={workflowId}
                   deployedState={deployedState}
                   isLoadingDeployedState={isLoadingDeployedState}
+                  isAwaitingSnapshot={isAwaitingSnapshot}
                   versions={versions}
                   versionsLoading={versionsLoading}
                   isPromotingVersion={isActivatingVersion || activateVersionMutation.isPending}

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/deploy.tsx

@@ -5,14 +5,11 @@ import { Chip, Tooltip, toast } from '@sim/emcn'
 import { useRegisterGlobalCommands } from '@/app/workspace/[workspaceId]/providers/global-commands-provider'
 import { DeployModal } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/components/deploy-modal/deploy-modal'
 import {
-  resolveDeployButtonStatus,
-  useChangeDetection,
-  useChangeDetectionCanary,
   useDeployment,
+  useDeploymentViewState,
   useDeployReadiness,
 } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks'
 import { useCurrentWorkflow } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-current-workflow'
-import { useDeployedWorkflowState, useDeploymentInfo } from '@/hooks/queries/deployments'
 import type { WorkspaceUserPermissions } from '@/hooks/use-user-permissions'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 
@@ -28,55 +25,21 @@ export function Deploy({ activeWorkflowId, userPermissions, disabled = false }:
   const isRegistryLoading = hydrationPhase === 'idle' || hydrationPhase === 'state-loading'
   const { hasBlocks } = useCurrentWorkflow()
 
-  const { data: deploymentInfo } = useDeploymentInfo(activeWorkflowId, {
-    enabled: !isRegistryLoading,
-  })
-  const isDeployed = deploymentInfo?.isDeployed ?? false
-
-  const isDeployedStateEnabled = Boolean(activeWorkflowId) && isDeployed && !isRegistryLoading
-  const {
-    data: deployedStateData,
-    isLoading: isLoadingDeployedState,
-    isFetching: isFetchingDeployedState,
-  } = useDeployedWorkflowState(activeWorkflowId, { enabled: isDeployedStateEnabled })
-  const deployedState = isDeployedStateEnabled ? (deployedStateData ?? null) : null
   const deployReadiness = useDeployReadiness(activeWorkflowId)
 
   /*
-   * `isLoading` (no snapshot yet), NOT `isFetching`. A background refetch — which
-   * `refetchOnWindowFocus` fires on every focus — still has the cached snapshot
-   * to compare against, so treating it as loading blanked the answer and pushed
-   * an already-correct "Update" back through "Live" and out again.
+   * One derivation for the chip, the modal preview and the modal footer. They
+   * previously each read their own mix of raw flags, which is how the preview
+   * could say "Deploy your workflow to see a preview" while the version list
+   * beneath it said `v1 (live)`.
    */
-  const { changeDetected, changedFields, isChangeDetectionSettling } = useChangeDetection({
+  const deployment = useDeploymentViewState({
     workflowId: activeWorkflowId,
-    deployedState,
-    isLoadingDeployedState,
-  })
-  const isDeploymentSettling = isChangeDetectionSettling || deployReadiness.isSyncing
-
-  const serverNeedsRedeployment = isDeployedStateEnabled
-    ? deploymentInfo?.needsRedeployment
-    : undefined
-
-  const buttonStatus = resolveDeployButtonStatus({
-    workflowId: activeWorkflowId,
-    isDeployed,
-    isAwaitingFirstDeployedState: isLoadingDeployedState,
-    clientChangeDetected: changeDetected,
-    hasDeployedState: deployedState !== null,
-    serverNeedsRedeployment,
-  })
-  const changeDetectedForModal = buttonStatus === 'changed'
-
-  useChangeDetectionCanary({
-    workflowId: activeWorkflowId,
-    clientChangeDetected: changeDetected,
-    clientChangedFields: changedFields,
-    serverNeedsRedeployment,
-    isSettling: isDeploymentSettling || deployedState === null,
-    isSettled: deployReadiness.status === 'ready',
+    enabled: !isRegistryLoading,
+    deployReadiness,
   })
+  const { status: buttonStatus, isDeployed, deployedState } = deployment
+  const isDeploymentSettling = deployment.isSettling
 
   const { isDeploying, handleDeployClick } = useDeployment({
     workflowId: activeWorkflowId,
@@ -135,7 +98,7 @@ export function Deploy({ activeWorkflowId, userPermissions, disabled = false }:
     if (isDeploying) {
       return 'Deploying...'
     }
-    if (isChangeDetectionSettling) {
+    if (isDeploymentSettling) {
       return 'Syncing deployment state...'
     }
     if (deployReadiness.isBlocked && !isDeployed) {
@@ -151,6 +114,22 @@ export function Deploy({ activeWorkflowId, userPermissions, disabled = false }:
   }
 
   const getButtonLabel = () => {
+    /*
+     * The label carries the busy state, matching every sibling control on this
+     * surface (`{isUndeploying ? 'Undeploying...' : 'Undeploy'}` in the modal
+     * footer) and the vocabulary `deployReadiness` already speaks. This chip was
+     * the one button that announced nothing and merely went disabled.
+     *
+     * Scoped to the deploy action, which is bounded by the mutation. The
+     * readiness states are deliberately NOT surfaced here: `saving` fires on
+     * every settled keystroke, so rendering it would reintroduce exactly the
+     * label churn this state machine exists to remove. Those stay in the
+     * tooltip, where they explain why the button is disabled.
+     */
+    if (isDeploying) {
+      return 'Deploying...'
+    }
+
     switch (buttonStatus) {
       case 'changed':
         return 'Update'
@@ -186,12 +165,8 @@ export function Deploy({ activeWorkflowId, userPermissions, disabled = false }:
         open={isModalOpen}
         onOpenChange={setIsModalOpen}
         workflowId={activeWorkflowId}
-        isDeployed={isDeployed}
-        needsRedeployment={changeDetectedForModal}
-        deployedState={deployedState}
-        isLoadingDeployedState={isLoadingDeployedState || isFetchingDeployedState}
+        deployment={deployment}
         deployReadiness={deployReadiness}
-        isDeploymentSettling={isDeploymentSettling}
       />
     </>
   )

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/index.ts

@@ -5,3 +5,5 @@ export { resolveDeployButtonStatus } from './use-deploy-button-status'
 export type { DeployReadiness } from './use-deploy-readiness'
 export { getDeployReadinessState, useDeployReadiness } from './use-deploy-readiness'
 export { useDeployment } from './use-deployment'
+export type { DeploymentViewState } from './use-deployment-view-state'
+export { useDeploymentViewState } from './use-deployment-view-state'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-deployment-view-state.ts

@@ -0,0 +1,107 @@
+import { useChangeDetection } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-change-detection'
+import { useChangeDetectionCanary } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-change-detection-canary'
+import {
+  type DeployButtonStatus,
+  resolveDeployButtonStatus,
+} from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-deploy-button-status'
+import type { DeployReadiness } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-deploy-readiness'
+import { useDeployedWorkflowState, useDeploymentInfo } from '@/hooks/queries/deployments'
+import type { WorkflowState } from '@/stores/workflows/workflow/types'
+
+export interface DeploymentViewState {
+  /** The single verdict every deploy surface renders from. */
+  status: DeployButtonStatus
+  isDeployed: boolean
+  /** The active deployment's snapshot, or null while it is not in hand. */
+  deployedState: WorkflowState | null
+  /**
+   * A snapshot is expected but has not arrived. Distinct from "there is no
+   * snapshot": the difference is what separates a skeleton from telling the user
+   * their workflow is not deployed.
+   */
+  isAwaitingSnapshot: boolean
+  isSettling: boolean
+  changeDetected: boolean
+  changedFields: string[]
+}
+
+interface UseDeploymentViewStateProps {
+  workflowId: string | null
+  enabled: boolean
+  deployReadiness: DeployReadiness
+}
+
+/**
+ * Owns every derived answer the deploy surface renders — the chip's label, the
+ * modal's preview, the modal's footer — so they cannot disagree.
+ *
+ * They used to. The chip resolved a status; the modal read raw `isDeployed` and
+ * `needsRedeployment`; the General tab decided "not deployed" from the *absence
+ * of a snapshot*. That last one is the defect that produced "Deploy your
+ * workflow to see a preview" sitting directly above a row reading `v1 (live)`:
+ * a missing snapshot is not evidence of anything, and rendering it as one made
+ * the modal contradict itself.
+ *
+ * Which is the same failure this PR fixes one layer down — several derivations
+ * of one fact, drifting — so it gets the same treatment: derive once, pass it
+ * down, and give the surfaces no raw material to re-derive from.
+ */
+export function useDeploymentViewState({
+  workflowId,
+  enabled,
+  deployReadiness,
+}: UseDeploymentViewStateProps): DeploymentViewState {
+  const { data: deploymentInfo } = useDeploymentInfo(workflowId, { enabled })
+  const isDeployed = deploymentInfo?.isDeployed ?? false
+
+  const snapshotEnabled = Boolean(workflowId) && isDeployed && enabled
+  const { data: deployedStateData, isLoading: isLoadingDeployedState } = useDeployedWorkflowState(
+    workflowId,
+    { enabled: snapshotEnabled }
+  )
+  const deployedState = snapshotEnabled ? (deployedStateData ?? null) : null
+
+  /*
+   * `isLoading` (no snapshot yet), NOT `isFetching`. A background refetch — which
+   * `refetchOnWindowFocus` fires on every focus — still has the cached snapshot
+   * to compare against, so treating it as loading blanked the answer and pushed
+   * an already-correct "Update" back through "Live" and out again.
+   */
+  const { changeDetected, changedFields, isChangeDetectionSettling } = useChangeDetection({
+    workflowId,
+    deployedState,
+    isLoadingDeployedState,
+  })
+
+  const serverNeedsRedeployment = snapshotEnabled ? deploymentInfo?.needsRedeployment : undefined
+
+  const status = resolveDeployButtonStatus({
+    workflowId,
+    isDeployed,
+    isAwaitingFirstDeployedState: isLoadingDeployedState,
+    clientChangeDetected: changeDetected,
+    hasDeployedState: deployedState !== null,
+    serverNeedsRedeployment,
+  })
+
+  const isSettling = isChangeDetectionSettling || deployReadiness.isSyncing
+
+  useChangeDetectionCanary({
+    workflowId,
+    clientChangeDetected: changeDetected,
+    clientChangedFields: changedFields,
+    serverNeedsRedeployment,
+    isSettling: isSettling || deployedState === null,
+    isSettled: deployReadiness.status === 'ready',
+  })
+
+  return {
+    status,
+    isDeployed,
+    deployedState,
+    isAwaitingSnapshot: snapshotEnabled && deployedState === null,
+    isSettling,
+    changeDetected,
+    changedFields,
+  }
+}

apps/sim/hooks/queries/deployments.ts

@@ -34,6 +34,8 @@ export type { ChatDetail, DeploymentVersionsResponse }
 export const DEPLOYMENT_INFO_STALE_TIME = 30 * 1000
 export const DEPLOYMENT_STATUS_REFETCH_INTERVAL = 5 * 1000
 export const DEPLOYED_WORKFLOW_STATE_STALE_TIME = 30 * 1000
+/** Retry cadence while the deployed snapshot is expected but not yet readable. */
+export const DEPLOYED_STATE_RECOVERY_INTERVAL = 3 * 1000
 export const DEPLOYMENT_VERSIONS_STALE_TIME = 30 * 1000
 export const CHAT_DEPLOYMENT_STATUS_STALE_TIME = 30 * 1000
 export const CHAT_DETAIL_STALE_TIME = 30 * 1000
@@ -158,6 +160,19 @@ export function useDeployedWorkflowState(
     queryFn: ({ signal }) => fetchDeployedWorkflowState(workflowId!, signal),
     enabled: Boolean(workflowId) && (options?.enabled ?? true),
     staleTime: DEPLOYED_WORKFLOW_STATE_STALE_TIME,
+    /*
+     * Callers enable this only once deployment info reports the workflow as
+     * deployed, so a null snapshot is a contradiction rather than an answer:
+     * the version exists but is not readable yet.
+     *
+     * Nothing re-invalidates this key when activation cuts over —
+     * `refetchDeploymentBoundary` fires while the query is still disabled, and a
+     * disabled query cannot be refetched — so the null was cached for the whole
+     * stale window. That is what put an empty preview next to a live version
+     * row. Retrying resolves the contradiction and stops the instant it does.
+     */
+    refetchInterval: (query) =>
+      query.state.data == null ? DEPLOYED_STATE_RECOVERY_INTERVAL : false,
   })
 }