@@ -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 (
 
@@ -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}
 
@@ -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}
       />
     </>
   )
 
@@ -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'
@@ -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,
+  }
+}
@@ -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,
   })
 }